Update.cvs/libc-ud-970819

1997-08-20 05:30  Ulrich Drepper  <drepper@cygnus.com>

	* catgets/catgets.c (catclose): Use __munmap instead of munmap.
	* catgets/gencat.c (read_input_file): Fix typo.

	* dirent/dirent.h: Make seekdir and telldir available for __USE_XOPEN.

	* elf/dl-load.c: Fix case of missing DT_RPATH in object which gets
	executed (e.g., when it is a static binary).

	* intl/bindtextdomain.c: Use strdup in glibc.  Correct comment.
	* intl/dcgettext.c: Likewise.
	* intl/dgettext.c: Likewise.
	* intl/explodename.c: Likewise.
	* intl/finddomain.c: Likewise.
	* intl/gettext.c: Likewise.
	* intl/gettext.h: Likewise.
	* intl/hash-string.h: Likewise.
	* intl/l10nflist.c: Likewise.
	* intl/libintl.h: Likewise.
	* intl/loadinfo.h: Likewise.
	* intl/loadmsgcat.c: Likewise.
	* intl/localealias.c: Likewise.
	* intl/textdomain.c: Likewise.

	Unify libio sources with code in libg++.
	* libio/fcloseall.c: Update and reformat copyright.  Protect use
	of weak_alias.  Use _IO_* thread macros instead of __libc_*.
	* libio/feof.c: Likewise.
	* libio/feof_u.c: Likewise.
	* libio/ferror.c: Likewise.
	* libio/ferror_u.c: Likewise.
	* libio/fgetc.c: Likewise.
	* libio/filedoalloc.c: Likewise.
	* libio/fileno.c: Likewise.
	* libio/fileops.c: Likewise.
	* libio/fputc.c: Likewise.
	* libio/fputc_u.c: Likewise.
	* libio/freopen.c: Likewise.
	* libio/fseek.c: Likewise.
	* libio/genops.c: Likewise.
	* libio/getc.c: Likewise.
	* libio/getc_u.c: Likewise.
	* libio/getchar.c: Likewise.
	* libio/getchar_u.c: Likewise.
	* libio/iofclose.c: Likewise.
	* libio/iofdopen.c: Likewise.
	* libio/iofflush.c: Likewise.
	* libio/iofflush_u.c: Likewise.
	* libio/iofgetpos.c: Likewise.
	* libio/iofgets.c: Likewise.
	* libio/iofopen.c: Likewise.
	* libio/iofopncook.c: Likewise.
	* libio/iofprintf.c: Likewise.
	* libio/iofputs.c: Likewise.
	* libio/iofread.c: Likewise.
	* libio/iofsetpos.c: Likewise.
	* libio/ioftell.c: Likewise.
	* libio/iofwrite.c: Likewise.
	* libio/iogetdelim.c: Likewise.
	* libio/iogetline.c: Likewise.
	* libio/iogets.c: Likewise.
	* libio/iopadn.c: Likewise.
	* libio/iopopen.c: Likewise.
	* libio/ioputs.c: Likewise.
	* libio/ioseekoff.c: Likewise.
	* libio/ioseekpos.c: Likewise.
	* libio/iosetbuffer.c: Likewise.
	* libio/iosetvbuf.c: Likewise.
	* libio/iosprintf.c: Likewise.
	* libio/ioungetc.c: Likewise.
	* libio/iovdprintf.c: Likewise.
	* libio/iovsprintf.c: Likewise.
	* libio/iovsscanf.c: Likewise.
	* libio/libio.h: Likewise.
	* libio/libioP.h: Likewise.
	* libio/obprintf.c: Likewise.
	* libio/pclose.c: Likewise.
	* libio/peekc.c: Likewise.
	* libio/putc.c: Likewise.
	* libio/putchar.c: Likewise.
	* libio/rewind.c: Likewise.
	* libio/setbuf.c: Likewise.
	* libio/setlinebuf.c: Likewise.
	* libio/stdfiles.c: Likewise.
	* libio/stdio.c: Likewise.
	* libio/strfile.h: Likewise.
	* libio/strops.c: Likewise.
	* libio/vasprintf.c: Likewise.
	* libio/vscanf.c: Likewise.
	* libio/vsnprintf.c: Likewise.

	* manual/libc.texinfo: Add menu entries for chapter on message
	translation.
	* manual/locale.texi: Correct next entry in @node for new chapter.
	* manual/search.texi: Likewise for previous link.
	* manual/message.texi: New file.
	* manual/startup.texi: Document LC_ALL, LC_MESSAGES, NLSPATH,
	setenv, unsetenv, and clearenv.
	* manual/string.texi: Fix typos.  Patch by Jim Meyering.

	* math/Makefile (test-longdouble-yes): Enable.  We want long double
	tests now.

	Crusade against strcat.
	* nis/nss_nisplus/nisplus-publickey.c: Remove uses of strcat.
	* stdlib/canonicalize.c: Likewise.

	* posix/glob.h: Define __const if necessary.  Use __const in all
	prototypes.

	* sysdeps/generic/stpcpy.c: Use K&R form to allow use in other
	GNU packages.

	* posix/wordexp.c: Completely reworked buffer handling for much
	better performance.  Patch by Tim Waugh.

	* socket/sys/sochet.h (getpeername): Fix type of LEN parameter,
	it must be socklen_t.

	* sysdeps/libm-i387/e_remainder.S: Pretty print.
	* sysdeps/libm-i387/e_remainderf.S: Likewise.
	* sysdeps/libm-i387/e_remainderl.S: Pop extra value for FPU stack.
	* sysdeps/libm-i387/s_cexp.S: Little optimization.
	* sysdeps/libm-i387/s_cexpl.S: Likewise.
	* sysdep/libm-ieee754/s_csinhl.c: Include <fenv.h>.

1997-08-18 15:21  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/if_index.c (if_nameindex): Fix memory leak
	in cleanup code.

1997-08-17  Paul Eggert  <eggert@twinsun.com>

	* tzset.c (__tzset_internal): Fix memory leak when the user
	specifies a TZ value that uses a default rule file.
	Do not assume US DST rules when the user specifies
	that there is no DST.

1997-08-10 19:17  Philip Blundell  <Philip.Blundell@pobox.com>

	* inet/getnameinfo.c: Tidy up.
	* sysdeps/posix/getaddrinfo.c: Likewise.

	* sysdeps/unix/sysv/linux/if_index.c (if_nametoindex): Return 0 if
	using stub code.
	(if_indextoname): Use SIOGIFNAME ioctl if the kernel supports it.
	(if_nameindex): Use alloca() rather than malloc(); use
	SIOCGIFCOUNT ioctl if the kernel supports it.

1997-08-16  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/unix/sysv/linux/sys/mount.h: Remove the IS_* macros,
	they operate on internal kernel structures and have no place in a
	user header.

1997-08-16  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* Makerules (lib%.so): Depend on $(+preinit) and $(+postinit).
	(build-shlib): Filter them out of $^.

1997-08-15  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* elf/dl-error.c (_dl_signal_error): Fix error message.

1997-08-16 04:06  Ulrich Drepper  <drepper@cygnus.com>

	* assert/assert.h [__USE_GNU]: Undefine assert_perror.
	Reported by Theodore C. Belding <Ted.Belding@umich.edu>.

1997-08-13  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* Makeconfig: Change object suffixes from *.[spgb]o to *.o[spgb]
	to avoid conflict with PO files.
	* Makerules: Likewise.
	* Rules: Likewise.
	* elf/Makefile: Likewise.
	* extra-lib.mk: Likewise.
	* gmon/Makefile: Likewise.
	* nis/Makefile: Likewise.
	* nss/Makefile: Likewise.
	* resolv/Makefile: Likewise.
	* rpm/Makefile: Likewise.
	* sunrpc/Makefile: Likewise.
	* sysdeps/sparc/elf/Makefile: Likewise.
	* sysdeps/sparc64/elf/Makefile: Likewise.
	* sysdeps/unix/sysv/linux/sparc/Makefile: Likewise.
	(ASFLAGS-.os): Renamed from as-FLAGS.os.

1 files changed, 340 insertions, 263 deletions

diff --git a/libio/genops.c b/libio/genops.c
index c08598686d..de9c826b9f 100644
--- a/libio/genops.c
+++ b/libio/genops.c
@@ -1,26 +1,27 @@
-/*
-Copyright (C) 1993, 1995 Free Software Foundation
-
-This file is part of the GNU IO Library.  This library is free
-software; you can redistribute it and/or modify it under the
-terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-This 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 General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this library; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-As a special exception, if you link this library with files
-compiled with a GNU compiler to produce an executable, this does not cause
-the resulting executable to be covered by the GNU General Public License.
-This exception does not however invalidate any other reasons why
-the executable file might be covered by the GNU General Public License. */
+/* Copyright (C) 1993, 1995, 1997 Free Software Foundation, Inc.
+   This file is part of the GNU IO Library.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this library; see the file COPYING.  If not, write to
+   the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   As a special exception, if you link this library with files
+   compiled with a GNU compiler to produce an executable, this does
+   not cause the resulting executable to be covered by the GNU General
+   Public License.  This exception does not however invalidate any
+   other reasons why the executable file might be covered by the GNU
+   General Public License.  */
 
 /* Generic or default I/O operations. */
 
@@ -31,41 +32,46 @@ the executable file might be covered by the GNU General Public License. */
 #include <string.h>
 
 void
-DEFUN(_IO_un_link, (fp),
-      _IO_FILE *fp)
-{
-  if (fp->_flags & _IO_LINKED) {
-    _IO_FILE **f;
-    for (f = &_IO_list_all; *f != NULL; f = &(*f)->_chain) {
-      if (*f == fp) {
-	*f = fp->_chain;
-	break;
-      }
+_IO_un_link (fp)
+     _IO_FILE *fp;
+{
+  if (fp->_flags & _IO_LINKED)
+    {
+      _IO_FILE **f;
+      for (f = &_IO_list_all; *f != NULL; f = &(*f)->_chain)
+	{
+	  if (*f == fp)
+	    {
+	      *f = fp->_chain;
+	      break;
+	    }
+	}
+      fp->_flags &= ~_IO_LINKED;
     }
-    fp->_flags &= ~_IO_LINKED;
-  }
 }
 
 void
-DEFUN(_IO_link_in, (fp),
-      _IO_FILE *fp)
+_IO_link_in (fp)
+     _IO_FILE *fp;
 {
-    if ((fp->_flags & _IO_LINKED) == 0) {
+    if ((fp->_flags & _IO_LINKED) == 0)
+      {
 	fp->_flags |= _IO_LINKED;
 	fp->_chain = _IO_list_all;
 	_IO_list_all = fp;
-    }
+      }
 }
 
 /* Return minimum _pos markers
    Assumes the current get area is the main get area. */
+static _IO_size_t _IO_least_marker __P ((_IO_FILE *fp));
 
-_IO_size_t
-DEFUN(_IO_least_marker, (fp),
-      register _IO_FILE *fp)
+static _IO_size_t
+_IO_least_marker (fp)
+     _IO_FILE *fp;
 {
   _IO_ssize_t least_so_far = fp->_IO_read_end - fp->_IO_read_base;
-  register struct _IO_marker *mark;
+  struct _IO_marker *mark;
   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
     if (mark->_pos < least_so_far)
       least_so_far = mark->_pos;
@@ -75,41 +81,51 @@ DEFUN(_IO_least_marker, (fp),
 /* Switch current get area from backup buffer to (start of) main get area. */
 
 void
-DEFUN(_IO_switch_to_main_get_area, (fp),
-      _IO_FILE *fp)
+_IO_switch_to_main_get_area (fp)
+     _IO_FILE *fp;
 {
   char *tmp;
   fp->_flags &= ~_IO_IN_BACKUP;
   /* Swap _IO_read_end and _IO_save_end. */
-  tmp = fp->_IO_read_end; fp->_IO_read_end= fp->_IO_save_end; fp->_IO_save_end= tmp;
+  tmp = fp->_IO_read_end;
+  fp->_IO_read_end = fp->_IO_save_end;
+  fp->_IO_save_end= tmp;
   /* Swap _IO_read_base and _IO_save_base. */
-  tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
+  tmp = fp->_IO_read_base;
+  fp->_IO_read_base = fp->_IO_save_base;
+  fp->_IO_save_base = tmp;
+
   fp->_IO_read_ptr = fp->_IO_read_base;
 }
 
 /* Switch current get area from main get area to (end of) backup area. */
 
 void
-DEFUN(_IO_switch_to_backup_area, (fp),
-     register _IO_FILE *fp)
+_IO_switch_to_backup_area (fp)
+     _IO_FILE *fp;
 {
   char *tmp;
   fp->_flags |= _IO_IN_BACKUP;
   /* Swap _IO_read_end and _IO_save_end. */
-  tmp = fp->_IO_read_end; fp->_IO_read_end = fp->_IO_save_end; fp->_IO_save_end = tmp;
+  tmp = fp->_IO_read_end;
+  fp->_IO_read_end = fp->_IO_save_end;
+  fp->_IO_save_end = tmp;
   /* Swap _gbase and _IO_save_base. */
-  tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
+  tmp = fp->_IO_read_base;
+  fp->_IO_read_base = fp->_IO_save_base;
+  fp->_IO_save_base = tmp;
+
   fp->_IO_read_ptr = fp->_IO_read_end;
 }
 
 int
-DEFUN(_IO_switch_to_get_mode, (fp),
-     register _IO_FILE *fp)
+_IO_switch_to_get_mode (fp)
+     _IO_FILE *fp;
 {
   if (fp->_IO_write_ptr > fp->_IO_write_base)
     if (_IO_OVERFLOW (fp, EOF) == EOF)
       return EOF;
-  if (_IO_in_backup(fp))
+  if (_IO_in_backup (fp))
     fp->_IO_read_base = fp->_IO_backup_base;
   else
     {
@@ -126,11 +142,11 @@ DEFUN(_IO_switch_to_get_mode, (fp),
 }
 
 void
-DEFUN(_IO_free_backup_area, (fp),
-     register _IO_FILE *fp)
+_IO_free_backup_area (fp)
+     _IO_FILE *fp;
 {
   if (_IO_in_backup (fp))
-    _IO_switch_to_main_get_area(fp);  /* Just in case. */
+    _IO_switch_to_main_get_area (fp);  /* Just in case. */
   free (fp->_IO_save_base);
   fp->_IO_save_base = NULL;
   fp->_IO_save_end = NULL;
@@ -139,13 +155,14 @@ DEFUN(_IO_free_backup_area, (fp),
 
 #if 0
 int
-DEFUN(_IO_switch_to_put_mode, (fp),
-      register _IO_FILE *fp)
+_IO_switch_to_put_mode (fp)
+     _IO_FILE *fp;
 {
   fp->_IO_write_base = fp->_IO_read_ptr;
   fp->_IO_write_ptr = fp->_IO_read_ptr;
   /* Following is wrong if line- or un-buffered? */
-  fp->_IO_write_end = fp->_flags & _IO_IN_BACKUP ? fp->_IO_read_end : fp->_IO_buf_end;
+  fp->_IO_write_end = (fp->_flags & _IO_IN_BACKUP
+		       ? fp->_IO_read_end : fp->_IO_buf_end);
 
   fp->_IO_read_ptr = fp->_IO_read_end;
   fp->_IO_read_base = fp->_IO_read_end;
@@ -156,18 +173,21 @@ DEFUN(_IO_switch_to_put_mode, (fp),
 #endif
 
 int
-DEFUN(__overflow, (f, ch),
-      _IO_FILE *f AND int ch)
+__overflow (f, ch)
+     _IO_FILE *f;
+     int ch;
 {
   return _IO_OVERFLOW (f, ch);
 }
 
-static int
-DEFUN(save_for_backup, (fp),
-      _IO_FILE *fp)
+static int save_for_backup __P ((_IO_FILE *fp));
+
+     static int
+save_for_backup (fp)
+     _IO_FILE *fp;
 {
   /* Append [_IO_read_base.._IO_read_end] to backup area. */
-  int least_mark = _IO_least_marker(fp);
+  int least_mark = _IO_least_marker (fp);
   /* needed_size is how much space we need in the backup area. */
   int needed_size = (fp->_IO_read_end - fp->_IO_read_base) - least_mark;
   int current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
@@ -178,22 +198,22 @@ DEFUN(save_for_backup, (fp),
     {
       char *new_buffer;
       avail = 100;
-      new_buffer = (char*)malloc(avail+needed_size);
+      new_buffer = (char *) malloc (avail + needed_size);
       if (new_buffer == NULL)
 	return EOF;		/* FIXME */
       if (least_mark < 0)
 	{
-	  memcpy(new_buffer + avail,
-		 fp->_IO_save_end + least_mark,
-		 -least_mark);
-	  memcpy(new_buffer +avail - least_mark,
-		 fp->_IO_read_base,
-		 fp->_IO_read_end - fp->_IO_read_base);
+	  memcpy (new_buffer + avail,
+		  fp->_IO_save_end + least_mark,
+		  -least_mark);
+	  memcpy (new_buffer + avail - least_mark,
+		  fp->_IO_read_base,
+		  fp->_IO_read_end - fp->_IO_read_base);
 	}
       else
-	memcpy(new_buffer + avail,
-	       fp->_IO_read_base + least_mark,
-	       needed_size);
+	memcpy (new_buffer + avail,
+		fp->_IO_read_base + least_mark,
+		needed_size);
       if (fp->_IO_save_base)
 	free (fp->_IO_save_base);
       fp->_IO_save_base = new_buffer;
@@ -204,17 +224,17 @@ DEFUN(save_for_backup, (fp),
       avail = current_Bsize - needed_size;
       if (least_mark < 0)
 	{
-	  memmove(fp->_IO_save_base + avail,
-		  fp->_IO_save_end + least_mark,
-		  -least_mark);
-	  memcpy(fp->_IO_save_base + avail - least_mark,
-		 fp->_IO_read_base,
-		 fp->_IO_read_end - fp->_IO_read_base);
+	  memmove (fp->_IO_save_base + avail,
+		   fp->_IO_save_end + least_mark,
+		   -least_mark);
+	  memcpy (fp->_IO_save_base + avail - least_mark,
+		  fp->_IO_read_base,
+		  fp->_IO_read_end - fp->_IO_read_base);
 	}
       else if (needed_size > 0)
-	memcpy(fp->_IO_save_base + avail,
-	       fp->_IO_read_base + least_mark,
-	       needed_size);
+	memcpy (fp->_IO_save_base + avail,
+		fp->_IO_read_base + least_mark,
+		needed_size);
     }
   /* FIXME: Dubious arithmetic if pointers are NULL */
   fp->_IO_backup_base = fp->_IO_save_base + avail;
@@ -226,59 +246,64 @@ DEFUN(save_for_backup, (fp),
 }
 
 int
-DEFUN(__underflow, (fp),
-      _IO_FILE *fp)
+__underflow (fp)
+     _IO_FILE *fp;
 {
-  if (_IO_in_put_mode(fp))
-    if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
+  if (_IO_in_put_mode (fp))
+    if (_IO_switch_to_get_mode (fp) == EOF)
+      return EOF;
   if (fp->_IO_read_ptr < fp->_IO_read_end)
-    return *(unsigned char*)fp->_IO_read_ptr;
-  if (_IO_in_backup(fp))
+    return *(unsigned char *) fp->_IO_read_ptr;
+  if (_IO_in_backup (fp))
     {
-      _IO_switch_to_main_get_area(fp);
+      _IO_switch_to_main_get_area (fp);
       if (fp->_IO_read_ptr < fp->_IO_read_end)
 	return *fp->_IO_read_ptr;
     }
-  if (_IO_have_markers(fp))
+  if (_IO_have_markers (fp))
     {
       if (save_for_backup (fp))
 	return EOF;
     }
-  else if (_IO_have_backup(fp))
-    _IO_free_backup_area(fp);
+  else if (_IO_have_backup (fp))
+    _IO_free_backup_area (fp);
   return _IO_UNDERFLOW (fp);
 }
 
 int
-DEFUN(__uflow, (fp),
-     _IO_FILE *fp)
+__uflow (fp)
+     _IO_FILE *fp;
 {
-  if (_IO_in_put_mode(fp))
-    if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
+  if (_IO_in_put_mode (fp))
+    if (_IO_switch_to_get_mode (fp) == EOF)
+      return EOF;
   if (fp->_IO_read_ptr < fp->_IO_read_end)
-    return *(unsigned char*)fp->_IO_read_ptr++;
-  if (_IO_in_backup(fp))
+    return *(unsigned char *) fp->_IO_read_ptr++;
+  if (_IO_in_backup (fp))
     {
-      _IO_switch_to_main_get_area(fp);
+      _IO_switch_to_main_get_area (fp);
       if (fp->_IO_read_ptr < fp->_IO_read_end)
 	return *fp->_IO_read_ptr++;
     }
-  if (_IO_have_markers(fp))
+  if (_IO_have_markers (fp))
     {
       if (save_for_backup (fp))
 	return EOF;
     }
-  else if (_IO_have_backup(fp))
-    _IO_free_backup_area(fp);
+  else if (_IO_have_backup (fp))
+    _IO_free_backup_area (fp);
   return _IO_UFLOW (fp);
 }
 
 void
-DEFUN(_IO_setb, (f, b, eb, a),
-      _IO_FILE *f AND char *b AND char *eb AND int a)
+_IO_setb (f, b, eb, a)
+     _IO_FILE *f;
+      char *b;
+     char *eb;
+     int a;
 {
   if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
-    FREE_BUF(f->_IO_buf_base, _IO_blen (f));
+    FREE_BUF (f->_IO_buf_base, _IO_blen (f));
   f->_IO_buf_base = b;
   f->_IO_buf_end = eb;
   if (a)
@@ -288,52 +313,55 @@ DEFUN(_IO_setb, (f, b, eb, a),
 }
 
 void
-DEFUN(_IO_doallocbuf, (fp),
-      register _IO_FILE *fp)
+_IO_doallocbuf (fp)
+     _IO_FILE *fp;
 {
   if (fp->_IO_buf_base)
     return;
   if (!(fp->_flags & _IO_UNBUFFERED))
     if (_IO_DOALLOCATE (fp) != EOF)
       return;
-  _IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
+  _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
 }
 
 int
-DEFUN(_IO_default_underflow, (fp),
-      _IO_FILE *fp)
+_IO_default_underflow (fp)
+     _IO_FILE *fp;
 {
   return EOF;
 }
 
 int
-DEFUN(_IO_default_uflow, (fp),
-      _IO_FILE *fp)
+_IO_default_uflow (fp)
+     _IO_FILE *fp;
 {
   int ch = _IO_UNDERFLOW (fp);
   if (ch == EOF)
     return EOF;
-  return *(unsigned char*)fp->_IO_read_ptr++;
+  return *(unsigned char *) fp->_IO_read_ptr++;
 }
 
 _IO_size_t
-DEFUN(_IO_default_xsputn, (f, data, n),
-      register _IO_FILE *f AND const void *data AND _IO_size_t n)
+_IO_default_xsputn (f, data, n)
+     _IO_FILE *f;
+     const void *data;
+     _IO_size_t n;
 {
-  register const char *s = (char*) data;
-  register _IO_size_t more = n;
+  const char *s = (char *) data;
+  _IO_size_t more = n;
   if (more <= 0)
     return 0;
   for (;;)
     {
-      _IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
+      /* Space available. */
+      _IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr;
       if (count > 0)
 	{
 	  if ((_IO_size_t) count > more)
 	    count = more;
 	  if (count > 20)
 	    {
-	      memcpy(f->_IO_write_ptr, s, count);
+	      memcpy (f->_IO_write_ptr, s, count);
 	      s += count;
 	      f->_IO_write_ptr += count;
             }
@@ -341,14 +369,15 @@ DEFUN(_IO_default_xsputn, (f, data, n),
 	    count = 0;
 	  else
 	    {
-	      register char *p = f->_IO_write_ptr;
-	      register _IO_ssize_t i;
-	      for (i = count; --i >= 0; ) *p++ = *s++;
+	      char *p = f->_IO_write_ptr;
+	      _IO_ssize_t i;
+	      for (i = count; --i >= 0; )
+		*p++ = *s++;
 	      f->_IO_write_ptr = p;
             }
 	  more -= count;
         }
-      if (more == 0 || __overflow(f, (unsigned char)*s++) == EOF)
+      if (more == 0 || __overflow (f, (unsigned char) *s++) == EOF)
 	break;
       more--;
     }
@@ -356,29 +385,34 @@ DEFUN(_IO_default_xsputn, (f, data, n),
 }
 
 _IO_size_t
-DEFUN(_IO_sgetn, (fp, data, n),
-      _IO_FILE *fp AND void *data AND _IO_size_t n)
+_IO_sgetn (fp, data, n)
+     _IO_FILE *fp;
+     void *data;
+     _IO_size_t n;
 {
   /* FIXME handle putback buffer here! */
   return _IO_XSGETN (fp, data, n);
 }
 
 _IO_size_t
-DEFUN(_IO_default_xsgetn, (fp, data, n),
-      _IO_FILE *fp AND void *data AND _IO_size_t n)
+_IO_default_xsgetn (fp, data, n)
+     _IO_FILE *fp;
+     void *data;
+     _IO_size_t n;
 {
-  register _IO_size_t more = n;
-  register char *s = (char*) data;
+  _IO_size_t more = n;
+  char *s = (char*) data;
   for (;;)
     {
-      _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr; /* Data available. */
+      /* Data available. */
+      _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr;
       if (count > 0)
 	{
 	  if ((_IO_size_t) count > more)
 	    count = more;
 	  if (count > 20)
 	    {
-	      memcpy(s, fp->_IO_read_ptr, count);
+	      memcpy (s, fp->_IO_read_ptr, count);
 	      s += count;
 	      fp->_IO_read_ptr += count;
 	    }
@@ -386,41 +420,47 @@ DEFUN(_IO_default_xsgetn, (fp, data, n),
 	    count = 0;
 	  else
 	    {
-	      register char *p = fp->_IO_read_ptr;
-	      register int i = (int)count;
-	      while (--i >= 0) *s++ = *p++;
+	      char *p = fp->_IO_read_ptr;
+	      int i = (int) count;
+	      while (--i >= 0)
+		*s++ = *p++;
 	      fp->_IO_read_ptr = p;
             }
             more -= count;
         }
-      if (more == 0 || __underflow(fp) == EOF)
+      if (more == 0 || __underflow (fp) == EOF)
 	break;
     }
   return n - more;
 }
 
+#if 0
+/* Seems not to be needed. --drepper */
 int
-DEFUN(_IO_sync, (fp),
-      register _IO_FILE *fp)
+_IO_sync (fp)
+     _IO_FILE *fp;
 {
   return 0;
 }
+#endif
 
-_IO_FILE*
-DEFUN(_IO_default_setbuf, (fp, p, len),
-      register _IO_FILE *fp AND char* p AND _IO_ssize_t len)
+_IO_FILE *
+_IO_default_setbuf (fp, p, len)
+     _IO_FILE *fp;
+     char *p;
+     _IO_ssize_t len;
 {
     if (_IO_SYNC (fp) == EOF)
 	return NULL;
     if (p == NULL || len == 0)
       {
 	fp->_flags |= _IO_UNBUFFERED;
-	_IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
+	_IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
       }
     else
       {
 	fp->_flags &= ~_IO_UNBUFFERED;
-	_IO_setb(fp, p, p+len, 0);
+	_IO_setb (fp, p, p+len, 0);
       }
     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
     fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
@@ -428,26 +468,29 @@ DEFUN(_IO_default_setbuf, (fp, p, len),
 }
 
 _IO_pos_t
-DEFUN(_IO_default_seekpos, (fp, pos, mode),
-      _IO_FILE *fp AND _IO_pos_t pos AND int mode)
+_IO_default_seekpos (fp, pos, mode)
+     _IO_FILE *fp;
+     _IO_pos_t pos;
+     int mode;
 {
-  return _IO_SEEKOFF (fp, _IO_pos_as_off(pos), 0, mode);
+  return _IO_SEEKOFF (fp, _IO_pos_as_off (pos), 0, mode);
 }
 
 int
-DEFUN(_IO_default_doallocate, (fp),
-      _IO_FILE *fp)
+_IO_default_doallocate (fp)
+     _IO_FILE *fp;
 {
   char *buf;
 
-  ALLOC_BUF(buf, _IO_BUFSIZ, EOF);
-  _IO_setb(fp, buf, buf+_IO_BUFSIZ, 1);
+  ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
+  _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1);
   return 1;
 }
 
 void
-DEFUN(_IO_init, (fp, flags),
-      register _IO_FILE *fp AND int flags)
+_IO_init (fp, flags)
+     _IO_FILE *fp;
+     int flags;
 {
   fp->_flags = _IO_MAGIC|flags;
   fp->_IO_buf_base = NULL;
@@ -471,8 +514,8 @@ DEFUN(_IO_init, (fp, flags),
 }
 
 int
-DEFUN(_IO_default_sync, (fp),
-      _IO_FILE *fp)
+_IO_default_sync (fp)
+     _IO_FILE *fp;
 {
   return 0;
 }
@@ -481,13 +524,14 @@ DEFUN(_IO_default_sync, (fp),
    current implementation, this function can get called twice! */
 
 void
-DEFUN(_IO_default_finish, (fp, dummy),
-      _IO_FILE *fp AND int dummy)
+_IO_default_finish (fp, dummy)
+     _IO_FILE *fp;
+     int dummy;
 {
   struct _IO_marker *mark;
   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
     {
-      FREE_BUF(fp->_IO_buf_base, _IO_blen (fp));
+      FREE_BUF (fp->_IO_buf_base, _IO_blen (fp));
       fp->_IO_buf_base = fp->_IO_buf_end = NULL;
     }
 
@@ -504,19 +548,23 @@ DEFUN(_IO_default_finish, (fp, dummy),
   _IO_lock_fini (*fp->_lock);
 #endif
 
-  _IO_un_link(fp);
+  _IO_un_link (fp);
 }
 
 _IO_pos_t
-DEFUN(_IO_default_seekoff, (fp, offset, dir, mode),
-      register _IO_FILE *fp AND _IO_off_t offset AND int dir AND int mode)
+_IO_default_seekoff (fp, offset, dir, mode)
+     _IO_FILE *fp;
+     _IO_off_t offset;
+     int dir;
+     int mode;
 {
     return _IO_pos_BAD;
 }
 
 int
-DEFUN(_IO_sputbackc, (fp, c),
-      register _IO_FILE *fp AND int c)
+_IO_sputbackc (fp, c)
+     _IO_FILE *fp;
+     int c;
 {
   int result;
 
@@ -524,7 +572,7 @@ DEFUN(_IO_sputbackc, (fp, c),
       && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
     {
       fp->_IO_read_ptr--;
-      result = (unsigned char)c;
+      result = (unsigned char) c;
     }
   else
     result = _IO_PBACKFAIL (fp, c);
@@ -536,15 +584,15 @@ DEFUN(_IO_sputbackc, (fp, c),
 }
 
 int
-DEFUN(_IO_sungetc, (fp),
-      register _IO_FILE *fp)
+_IO_sungetc (fp)
+     _IO_FILE *fp;
 {
   int result;
 
   if (fp->_IO_read_ptr > fp->_IO_read_base)
     {
       fp->_IO_read_ptr--;
-      result = (unsigned char)*fp->_IO_read_ptr;
+      result = (unsigned char) *fp->_IO_read_ptr;
     }
   else
     result = _IO_PBACKFAIL (fp, EOF);
@@ -556,9 +604,12 @@ DEFUN(_IO_sungetc, (fp),
 }
 
 #if 0 /* Work in progress */
+/* Seems not to be needed.  */
+#if 0
 void
-DEFUN(_IO_set_column, (fp, c),
-      register _IO_FILE *fp AND int c)
+_IO_set_column (fp, c)
+     _IO_FILE *fp;
+     int c;
 {
   if (c == -1)
     fp->_column = -1;
@@ -567,39 +618,46 @@ DEFUN(_IO_set_column, (fp, c),
 }
 #else
 int
-DEFUN(_IO_set_column, (fp, i),
-      register _IO_FILE *fp AND int i)
+_IO_set_column (fp, i)
+     _IO_FILE *fp;
+     int i;
 {
-  fp->_cur_column = i+1;
+  fp->_cur_column = i + 1;
   return 0;
 }
 #endif
+#endif
 
 
 unsigned
-DEFUN(_IO_adjust_column, (start, line, count),
-      unsigned start AND const char *line AND int count)
+_IO_adjust_column (start, line, count)
+     unsigned start;
+     const char *line;
+     int count;
 {
-  register const char *ptr = line + count;
+  const char *ptr = line + count;
   while (ptr > line)
     if (*--ptr == '\n')
       return line + count - ptr - 1;
   return start + count;
 }
 
+#if 0
+/* Seems not to be needed. --drepper */
 int
-DEFUN(_IO_get_column, (fp),
-      register _IO_FILE *fp)
+_IO_get_column (fp)
+     _IO_FILE *fp;
 {
   if (fp->_cur_column)
-    return _IO_adjust_column(fp->_cur_column - 1,
+    return _IO_adjust_column (fp->_cur_column - 1,
 			      fp->_IO_write_base,
 			      fp->_IO_write_ptr - fp->_IO_write_base);
   return -1;
 }
+#endif
 
 int
-DEFUN_VOID(_IO_flush_all)
+_IO_flush_all ()
 {
   int result = 0;
   _IO_FILE *fp;
@@ -611,7 +669,7 @@ DEFUN_VOID(_IO_flush_all)
 }
 
 void
-DEFUN_VOID(_IO_flush_all_linebuffered)
+_IO_flush_all_linebuffered ()
 {
   _IO_FILE *fp;
   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
@@ -619,8 +677,10 @@ DEFUN_VOID(_IO_flush_all_linebuffered)
       _IO_OVERFLOW (fp, EOF);
 }
 
-void
-DEFUN_VOID(_IO_unbuffer_all)
+static void _IO_unbuffer_all __P ((void));
+
+static void
+_IO_unbuffer_all ()
 {
   _IO_FILE *fp;
   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
@@ -629,7 +689,7 @@ DEFUN_VOID(_IO_unbuffer_all)
 }
 
 void
-DEFUN_VOID(_IO_cleanup)
+_IO_cleanup ()
 {
   _IO_flush_all ();
 
@@ -644,13 +704,14 @@ DEFUN_VOID(_IO_cleanup)
 }
 
 void
-DEFUN(_IO_init_marker, (marker, fp),
-      struct _IO_marker *marker AND _IO_FILE *fp)
+_IO_init_marker (marker, fp)
+     struct _IO_marker *marker;
+     _IO_FILE *fp;
 {
   marker->_sbuf = fp;
-  if (_IO_in_put_mode(fp))
-    _IO_switch_to_get_mode(fp);
-  if (_IO_in_backup(fp))
+  if (_IO_in_put_mode (fp))
+    _IO_switch_to_get_mode (fp);
+  if (_IO_in_backup (fp))
     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
   else
     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
@@ -661,11 +722,11 @@ DEFUN(_IO_init_marker, (marker, fp),
 }
 
 void
-DEFUN(_IO_remove_marker, (marker),
-      register struct _IO_marker *marker)
+_IO_remove_marker (marker)
+     struct _IO_marker *marker;
 {
   /* Unlink from sb's chain. */
-  register struct _IO_marker **ptr = &marker->_sbuf->_markers;
+  struct _IO_marker **ptr = &marker->_sbuf->_markers;
   for (; ; ptr = &(*ptr)->_next)
     {
       if (*ptr == NULL)
@@ -685,21 +746,22 @@ DEFUN(_IO_remove_marker, (marker),
 #define BAD_DELTA EOF
 
 int
-DEFUN(_IO_marker_difference, (mark1, mark2),
-      struct _IO_marker *mark1 AND struct _IO_marker *mark2)
+_IO_marker_difference (mark1, mark2)
+     struct _IO_marker *mark1;
+     struct _IO_marker *mark2;
 {
   return mark1->_pos - mark2->_pos;
 }
 
 /* Return difference between MARK and current position of MARK's stream. */
 int
-DEFUN(_IO_marker_delta, (mark),
-      struct _IO_marker *mark)
+_IO_marker_delta (mark)
+     struct _IO_marker *mark;
 {
   int cur_pos;
   if (mark->_sbuf == NULL)
     return BAD_DELTA;
-  if (_IO_in_backup(mark->_sbuf))
+  if (_IO_in_backup (mark->_sbuf))
     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
   else
     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
@@ -707,135 +769,150 @@ DEFUN(_IO_marker_delta, (mark),
 }
 
 int
-DEFUN(_IO_seekmark, (fp, mark, delta),
-      _IO_FILE *fp AND struct _IO_marker *mark AND int delta)
+_IO_seekmark (fp, mark, delta)
+     _IO_FILE *fp;
+     struct _IO_marker *mark;
+     int delta;
 {
   if (mark->_sbuf != fp)
     return EOF;
  if (mark->_pos >= 0)
     {
-      if (_IO_in_backup(fp))
-	_IO_switch_to_main_get_area(fp);
+      if (_IO_in_backup (fp))
+	_IO_switch_to_main_get_area (fp);
       fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
     }
   else
     {
-      if (!_IO_in_backup(fp))
-	_IO_switch_to_backup_area(fp);
+      if (!_IO_in_backup (fp))
+	_IO_switch_to_backup_area (fp);
       fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
     }
   return 0;
 }
 
 void
-DEFUN(_IO_unsave_markers, (fp),
-     register _IO_FILE *fp)
+_IO_unsave_markers (fp)
+     _IO_FILE *fp;
 {
-  register struct _IO_marker *mark = fp->_markers;
+  struct _IO_marker *mark = fp->_markers;
   if (mark)
     {
 #ifdef TODO
-      streampos offset = seekoff(0, ios::cur, ios::in);
+      streampos offset = seekoff (0, ios::cur, ios::in);
       if (offset != EOF)
 	{
-	  offset += eGptr() - Gbase();
+	  offset += eGptr () - Gbase ();
 	  for ( ; mark != NULL; mark = mark->_next)
-	    mark->set_streampos(mark->_pos + offset);
+	    mark->set_streampos (mark->_pos + offset);
 	}
     else
       {
 	for ( ; mark != NULL; mark = mark->_next)
-	  mark->set_streampos(EOF);
+	  mark->set_streampos (EOF);
       }
 #endif
       fp->_markers = 0;
     }
 
-  if (_IO_have_backup(fp))
-    _IO_free_backup_area(fp);
+  if (_IO_have_backup (fp))
+    _IO_free_backup_area (fp);
 }
 
+#if 0
+/* Seems not to be needed. --drepper */
 int
-DEFUN(_IO_nobackup_pbackfail, (fp, c),
-     register _IO_FILE *fp AND int c)
+_IO_nobackup_pbackfail (fp, c)
+     _IO_FILE *fp;
+     int c;
 {
   if (fp->_IO_read_ptr > fp->_IO_read_base)
 	fp->_IO_read_ptr--;
   if (c != EOF && *fp->_IO_read_ptr != c)
       *fp->_IO_read_ptr = c;
-  return (unsigned char)c;
+  return (unsigned char) c;
 }
+#endif
 
 int
-DEFUN(_IO_default_pbackfail, (fp, c),
-      register _IO_FILE *fp AND int c)
+_IO_default_pbackfail (fp, c)
+     _IO_FILE *fp;
+     int c;
 {
   if (fp->_IO_read_ptr <= fp->_IO_read_base)
-      {
-	/* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
-	if (_IO_have_backup(fp) && !_IO_in_backup(fp))
-	  _IO_switch_to_backup_area(fp);
-
-	if (!_IO_have_backup(fp))
-	  {
-	    /* No backup buffer: allocate one. */
-	    /* Use nshort buffer, if unused? (probably not)  FIXME */
-	    int backup_size = 128;
-	    char *bbuf = (char*)malloc(backup_size);
-	    if (bbuf == NULL)
-	      return EOF;
-	    fp->_IO_save_base = bbuf;
-	    fp->_IO_save_end = fp->_IO_save_base + backup_size;
-	    fp->_IO_backup_base = fp->_IO_save_end;
-	    _IO_switch_to_backup_area(fp);
-	  }
-	else if (fp->_IO_read_ptr <= fp->_IO_read_base)
-	  {
-	    /* Increase size of existing backup buffer. */
-	    _IO_size_t new_size;
-	    _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
-	    char *new_buf;
-	    new_size = 2 * old_size;
-	    new_buf = (char*)malloc(new_size);
-	    if (new_buf == NULL)
-	      return EOF;
-	    memcpy(new_buf+(new_size-old_size), fp->_IO_read_base, old_size);
-	    free (fp->_IO_read_base);
-	    _IO_setg(fp,
-		     new_buf, new_buf+(new_size-old_size), new_buf+new_size);
-	    fp->_IO_backup_base = fp->_IO_read_ptr;
-	  }
-      }
-  fp->_IO_read_ptr--;
+    {
+      /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
+      if (_IO_have_backup (fp) && !_IO_in_backup (fp))
+	_IO_switch_to_backup_area (fp);
+
+      if (!_IO_have_backup (fp))
+	{
+	  /* No backup buffer: allocate one. */
+	  /* Use nshort buffer, if unused? (probably not)  FIXME */
+	  int backup_size = 128;
+	  char *bbuf = (char *) malloc (backup_size);
+	  if (bbuf == NULL)
+	    return EOF;
+	  fp->_IO_save_base = bbuf;
+	  fp->_IO_save_end = fp->_IO_save_base + backup_size;
+	  fp->_IO_backup_base = fp->_IO_save_end;
+	  _IO_switch_to_backup_area (fp);
+	}
+      else if (fp->_IO_read_ptr <= fp->_IO_read_base)
+	{
+	  /* Increase size of existing backup buffer. */
+	  _IO_size_t new_size;
+	  _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
+	  char *new_buf;
+	  new_size = 2 * old_size;
+	  new_buf = (char *) malloc (new_size);
+	  if (new_buf == NULL)
+	    return EOF;
+	  memcpy (new_buf + (new_size - old_size), fp->_IO_read_base,
+		  old_size);
+	  free (fp->_IO_read_base);
+	  _IO_setg (fp, new_buf, new_buf + (new_size - old_size),
+		    new_buf + new_size);
+	  fp->_IO_backup_base = fp->_IO_read_ptr;
+	}
+    }
+  --fp->_IO_read_ptr;
   if (c != EOF && *fp->_IO_read_ptr != c)
     *fp->_IO_read_ptr = c;
-  return (unsigned char)*fp->_IO_read_ptr;
+  return (unsigned char) *fp->_IO_read_ptr;
 }
 
 _IO_pos_t
-DEFUN(_IO_default_seek, (fp, offset, dir),
-      _IO_FILE *fp AND _IO_off_t offset AND int dir)
+_IO_default_seek (fp, offset, dir)
+     _IO_FILE *fp;
+     _IO_off_t offset;
+     int dir;
 {
   return _IO_pos_BAD;
 }
 
 int
-DEFUN(_IO_default_stat, (fp, st),
-      _IO_FILE *fp AND void* st)
+_IO_default_stat (fp, st)
+     _IO_FILE *fp;
+     void* st;
 {
   return EOF;
 }
 
 _IO_ssize_t
-DEFUN(_IO_default_read, (fp, data, n),
-      register _IO_FILE* fp AND void* data AND _IO_ssize_t n)
+_IO_default_read (fp, data, n)
+     _IO_FILE* fp;
+     void *data;
+     _IO_ssize_t n;
 {
   return -1;
 }
 
 _IO_ssize_t
-DEFUN(_IO_default_write, (fp, data, n),
-      register _IO_FILE* fp AND const void* data AND _IO_ssize_t n)
+_IO_default_write (fp, data, n)
+     _IO_FILE *fp;
+     const void *data;
+     _IO_ssize_t n;
 {
   return 0;
 }
@@ -851,7 +928,7 @@ DEFUN(_IO_default_write, (fp, data, n),
 #else
 struct __io_defs {
     __io_defs() { }
-    ~__io_defs() { _IO_cleanup(); }
+    ~__io_defs() { _IO_cleanup (); }
 };
 __io_defs io_defs__;
 #endif