diff options
Diffstat (limited to 'libio/genops.c')
| -rw-r--r-- | libio/genops.c | 603 |
1 files changed, 340 insertions, 263 deletions
diff --git a/libio/genops.c b/libio/genops.c index c085986..de9c826 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 |