aboutsummaryrefslogtreecommitdiff
path: root/libio/genops.c
diff options
context:
space:
mode:
Diffstat (limited to 'libio/genops.c')
-rw-r--r--libio/genops.c603
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