-/* Copyright (C) 1993-2013 Free Software Foundation, Inc.
+/* Copyright (C) 1993-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
-#ifdef _LIBC
#include <sched.h>
-#endif
#ifdef _IO_MTSAFE_IO
static _IO_lock_t list_all_lock = _IO_lock_initializer;
#endif
-/* Used to signal modifications to the list of FILE decriptors. */
-static int _IO_list_all_stamp;
-
-
-static _IO_FILE *run_fp;
+static FILE *run_fp;
#ifdef _IO_MTSAFE_IO
static void
#endif
void
-_IO_un_link (fp)
- struct _IO_FILE_plus *fp;
+_IO_un_link (struct _IO_FILE_plus *fp)
{
if (fp->file._flags & _IO_LINKED)
{
- struct _IO_FILE **f;
+ FILE **f;
#ifdef _IO_MTSAFE_IO
_IO_cleanup_region_start_noarg (flush_cleanup);
_IO_lock_lock (list_all_lock);
- run_fp = (_IO_FILE *) fp;
- _IO_flockfile ((_IO_FILE *) fp);
+ run_fp = (FILE *) fp;
+ _IO_flockfile ((FILE *) fp);
#endif
if (_IO_list_all == NULL)
;
else if (fp == _IO_list_all)
- {
- _IO_list_all = (struct _IO_FILE_plus *) _IO_list_all->file._chain;
- ++_IO_list_all_stamp;
- }
+ _IO_list_all = (struct _IO_FILE_plus *) _IO_list_all->file._chain;
else
for (f = &_IO_list_all->file._chain; *f; f = &(*f)->_chain)
- if (*f == (_IO_FILE *) fp)
+ if (*f == (FILE *) fp)
{
*f = fp->file._chain;
- ++_IO_list_all_stamp;
break;
}
fp->file._flags &= ~_IO_LINKED;
#ifdef _IO_MTSAFE_IO
- _IO_funlockfile ((_IO_FILE *) fp);
+ _IO_funlockfile ((FILE *) fp);
run_fp = NULL;
_IO_lock_unlock (list_all_lock);
_IO_cleanup_region_end (0);
libc_hidden_def (_IO_un_link)
void
-_IO_link_in (fp)
- struct _IO_FILE_plus *fp;
+_IO_link_in (struct _IO_FILE_plus *fp)
{
if ((fp->file._flags & _IO_LINKED) == 0)
{
#ifdef _IO_MTSAFE_IO
_IO_cleanup_region_start_noarg (flush_cleanup);
_IO_lock_lock (list_all_lock);
- run_fp = (_IO_FILE *) fp;
- _IO_flockfile ((_IO_FILE *) fp);
+ run_fp = (FILE *) fp;
+ _IO_flockfile ((FILE *) fp);
#endif
- fp->file._chain = (_IO_FILE *) _IO_list_all;
+ fp->file._chain = (FILE *) _IO_list_all;
_IO_list_all = fp;
- ++_IO_list_all_stamp;
#ifdef _IO_MTSAFE_IO
- _IO_funlockfile ((_IO_FILE *) fp);
+ _IO_funlockfile ((FILE *) fp);
run_fp = NULL;
_IO_lock_unlock (list_all_lock);
_IO_cleanup_region_end (0);
/* Return minimum _pos markers
Assumes the current get area is the main get area. */
-_IO_ssize_t _IO_least_marker (_IO_FILE *fp, char *end_p);
+ssize_t _IO_least_marker (FILE *fp, char *end_p);
-_IO_ssize_t
-_IO_least_marker (fp, end_p)
- _IO_FILE *fp;
- char *end_p;
+ssize_t
+_IO_least_marker (FILE *fp, char *end_p)
{
- _IO_ssize_t least_so_far = end_p - fp->_IO_read_base;
+ ssize_t least_so_far = end_p - fp->_IO_read_base;
struct _IO_marker *mark;
for (mark = fp->_markers; mark != NULL; mark = mark->_next)
if (mark->_pos < least_so_far)
/* Switch current get area from backup buffer to (start of) main get area. */
void
-_IO_switch_to_main_get_area (fp)
- _IO_FILE *fp;
+_IO_switch_to_main_get_area (FILE *fp)
{
char *tmp;
fp->_flags &= ~_IO_IN_BACKUP;
/* Switch current get area from main get area to (end of) backup area. */
void
-_IO_switch_to_backup_area (fp)
- _IO_FILE *fp;
+_IO_switch_to_backup_area (FILE *fp)
{
char *tmp;
fp->_flags |= _IO_IN_BACKUP;
}
int
-_IO_switch_to_get_mode (fp)
- _IO_FILE *fp;
+_IO_switch_to_get_mode (FILE *fp)
{
if (fp->_IO_write_ptr > fp->_IO_write_base)
if (_IO_OVERFLOW (fp, EOF) == EOF)
libc_hidden_def (_IO_switch_to_get_mode)
void
-_IO_free_backup_area (fp)
- _IO_FILE *fp;
+_IO_free_backup_area (FILE *fp)
{
if (_IO_in_backup (fp))
_IO_switch_to_main_get_area (fp); /* Just in case. */
}
libc_hidden_def (_IO_free_backup_area)
-#if 0
int
-_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_read_ptr = fp->_IO_read_end;
- fp->_IO_read_base = fp->_IO_read_end;
-
- fp->_flags |= _IO_CURRENTLY_PUTTING;
- return 0;
-}
-#endif
-
-int
-__overflow (f, ch)
- _IO_FILE *f;
- int ch;
+__overflow (FILE *f, int ch)
{
/* This is a single-byte stream. */
if (f->_mode == 0)
}
libc_hidden_def (__overflow)
-static int save_for_backup (_IO_FILE *fp, char *end_p)
-#ifdef _LIBC
- internal_function
-#endif
- ;
-
static int
-#ifdef _LIBC
-internal_function
-#endif
-save_for_backup (fp, end_p)
- _IO_FILE *fp;
- char *end_p;
+save_for_backup (FILE *fp, char *end_p)
{
/* Append [_IO_read_base..end_p] to backup area. */
- _IO_ssize_t least_mark = _IO_least_marker (fp, end_p);
+ ssize_t least_mark = _IO_least_marker (fp, end_p);
/* needed_size is how much space we need in the backup area. */
- _IO_size_t needed_size = (end_p - fp->_IO_read_base) - least_mark;
+ size_t needed_size = (end_p - fp->_IO_read_base) - least_mark;
/* FIXME: Dubious arithmetic if pointers are NULL */
- _IO_size_t current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
- _IO_size_t avail; /* Extra space available for future expansion. */
- _IO_ssize_t delta;
+ size_t current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
+ size_t avail; /* Extra space available for future expansion. */
+ ssize_t delta;
struct _IO_marker *mark;
if (needed_size > current_Bsize)
{
return EOF; /* FIXME */
if (least_mark < 0)
{
-#ifdef _LIBC
__mempcpy (__mempcpy (new_buffer + avail,
fp->_IO_save_end + least_mark,
-least_mark),
fp->_IO_read_base,
end_p - fp->_IO_read_base);
-#else
- memcpy (new_buffer + avail,
- fp->_IO_save_end + least_mark,
- -least_mark);
- memcpy (new_buffer + avail - least_mark,
- fp->_IO_read_base,
- end_p - fp->_IO_read_base);
-#endif
}
else
memcpy (new_buffer + avail,
}
int
-__underflow (fp)
- _IO_FILE *fp;
+__underflow (FILE *fp)
{
-#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
return EOF;
-#endif
if (fp->_mode == 0)
_IO_fwide (fp, -1);
libc_hidden_def (__underflow)
int
-__uflow (fp)
- _IO_FILE *fp;
+__uflow (FILE *fp)
{
-#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
return EOF;
-#endif
if (fp->_mode == 0)
_IO_fwide (fp, -1);
libc_hidden_def (__uflow)
void
-_IO_setb (f, b, eb, a)
- _IO_FILE *f;
- char *b;
- char *eb;
- int a;
+_IO_setb (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 (f->_IO_buf_base);
f->_IO_buf_base = b;
f->_IO_buf_end = eb;
if (a)
libc_hidden_def (_IO_setb)
void
-_IO_doallocbuf (fp)
- _IO_FILE *fp;
+_IO_doallocbuf (FILE *fp)
{
if (fp->_IO_buf_base)
return;
libc_hidden_def (_IO_doallocbuf)
int
-_IO_default_underflow (fp)
- _IO_FILE *fp;
+_IO_default_underflow (FILE *fp)
{
return EOF;
}
int
-_IO_default_uflow (fp)
- _IO_FILE *fp;
+_IO_default_uflow (FILE *fp)
{
int ch = _IO_UNDERFLOW (fp);
if (ch == EOF)
}
libc_hidden_def (_IO_default_uflow)
-_IO_size_t
-_IO_default_xsputn (f, data, n)
- _IO_FILE *f;
- const void *data;
- _IO_size_t n;
+size_t
+_IO_default_xsputn (FILE *f, const void *data, size_t n)
{
const char *s = (char *) data;
- _IO_size_t more = n;
+ size_t more = n;
if (more <= 0)
return 0;
for (;;)
/* Space available. */
if (f->_IO_write_ptr < f->_IO_write_end)
{
- _IO_size_t count = f->_IO_write_end - f->_IO_write_ptr;
+ size_t count = f->_IO_write_end - f->_IO_write_ptr;
if (count > more)
count = more;
if (count > 20)
{
-#ifdef _LIBC
f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
-#else
- memcpy (f->_IO_write_ptr, s, count);
- f->_IO_write_ptr += count;
-#endif
s += count;
}
else if (count)
{
char *p = f->_IO_write_ptr;
- _IO_ssize_t i;
+ ssize_t i;
for (i = count; --i >= 0; )
*p++ = *s++;
f->_IO_write_ptr = p;
}
libc_hidden_def (_IO_default_xsputn)
-_IO_size_t
-_IO_sgetn (fp, data, n)
- _IO_FILE *fp;
- void *data;
- _IO_size_t n;
+size_t
+_IO_sgetn (FILE *fp, void *data, size_t n)
{
/* FIXME handle putback buffer here! */
return _IO_XSGETN (fp, data, n);
}
libc_hidden_def (_IO_sgetn)
-_IO_size_t
-_IO_default_xsgetn (fp, data, n)
- _IO_FILE *fp;
- void *data;
- _IO_size_t n;
+size_t
+_IO_default_xsgetn (FILE *fp, void *data, size_t n)
{
- _IO_size_t more = n;
+ size_t more = n;
char *s = (char*) data;
for (;;)
{
/* Data available. */
if (fp->_IO_read_ptr < fp->_IO_read_end)
{
- _IO_size_t count = fp->_IO_read_end - fp->_IO_read_ptr;
+ size_t count = fp->_IO_read_end - fp->_IO_read_ptr;
if (count > more)
count = more;
if (count > 20)
{
-#ifdef _LIBC
s = __mempcpy (s, fp->_IO_read_ptr, count);
-#else
- memcpy (s, fp->_IO_read_ptr, count);
- s += count;
-#endif
fp->_IO_read_ptr += count;
}
else if (count)
}
libc_hidden_def (_IO_default_xsgetn)
-#if 0
-/* Seems not to be needed. --drepper */
-int
-_IO_sync (fp)
- _IO_FILE *fp;
-{
- return 0;
-}
-#endif
-
-_IO_FILE *
-_IO_default_setbuf (fp, p, len)
- _IO_FILE *fp;
- char *p;
- _IO_ssize_t len;
+FILE *
+_IO_default_setbuf (FILE *fp, char *p, ssize_t len)
{
if (_IO_SYNC (fp) == EOF)
return NULL;
return fp;
}
-_IO_off64_t
-_IO_default_seekpos (fp, pos, mode)
- _IO_FILE *fp;
- _IO_off64_t pos;
- int mode;
+off64_t
+_IO_default_seekpos (FILE *fp, off64_t pos, int mode)
{
return _IO_SEEKOFF (fp, pos, 0, mode);
}
int
-_IO_default_doallocate (fp)
- _IO_FILE *fp;
+_IO_default_doallocate (FILE *fp)
{
char *buf;
- ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
- _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1);
+ buf = malloc(BUFSIZ);
+ if (__glibc_unlikely (buf == NULL))
+ return EOF;
+
+ _IO_setb (fp, buf, buf+BUFSIZ, 1);
return 1;
}
libc_hidden_def (_IO_default_doallocate)
void
-_IO_init (fp, flags)
- _IO_FILE *fp;
- int flags;
+_IO_init_internal (FILE *fp, int flags)
{
_IO_no_init (fp, flags, -1, NULL, NULL);
}
-libc_hidden_def (_IO_init)
void
-_IO_old_init (fp, flags)
- _IO_FILE *fp;
- int flags;
+_IO_init (FILE *fp, int flags)
+{
+ IO_set_accept_foreign_vtables (&_IO_vtable_check);
+ _IO_init_internal (fp, flags);
+}
+
+static int stdio_needs_locking;
+
+/* In a single-threaded process most stdio locks can be omitted. After
+ _IO_enable_locks is called, locks are not optimized away any more.
+ It must be first called while the process is still single-threaded.
+
+ This lock optimization can be disabled on a per-file basis by setting
+ _IO_FLAGS2_NEED_LOCK, because a file can have user-defined callbacks
+ or can be locked with flockfile and then a thread may be created
+ between a lock and unlock, so omitting the lock is not valid.
+
+ Here we have to make sure that the flag is set on all existing files
+ and files created later. */
+void
+_IO_enable_locks (void)
+{
+ _IO_ITER i;
+
+ if (stdio_needs_locking)
+ return;
+ stdio_needs_locking = 1;
+ for (i = _IO_iter_begin (); i != _IO_iter_end (); i = _IO_iter_next (i))
+ _IO_iter_file (i)->_flags2 |= _IO_FLAGS2_NEED_LOCK;
+}
+libc_hidden_def (_IO_enable_locks)
+
+void
+_IO_old_init (FILE *fp, int flags)
{
fp->_flags = _IO_MAGIC|flags;
fp->_flags2 = 0;
+ if (stdio_needs_locking)
+ fp->_flags2 |= _IO_FLAGS2_NEED_LOCK;
fp->_IO_buf_base = NULL;
fp->_IO_buf_end = NULL;
fp->_IO_read_base = NULL;
}
void
-_IO_no_init (fp, flags, orientation, wd, jmp)
- _IO_FILE *fp;
- int flags;
- int orientation;
- struct _IO_wide_data *wd;
- const struct _IO_jump_t *jmp;
+_IO_no_init (FILE *fp, int flags, int orientation,
+ struct _IO_wide_data *wd, const struct _IO_jump_t *jmp)
{
_IO_old_init (fp, flags);
fp->_mode = orientation;
-#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
if (orientation >= 0)
{
fp->_wide_data = wd;
/* Cause predictable crash when a wide function is called on a byte
stream. */
fp->_wide_data = (struct _IO_wide_data *) -1L;
-#endif
fp->_freeres_list = NULL;
}
int
-_IO_default_sync (fp)
- _IO_FILE *fp;
+_IO_default_sync (FILE *fp)
{
return 0;
}
current implementation, this function can get called twice! */
void
-_IO_default_finish (fp, dummy)
- _IO_FILE *fp;
- int dummy;
+_IO_default_finish (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 (fp->_IO_buf_base);
fp->_IO_buf_base = fp->_IO_buf_end = NULL;
}
}
libc_hidden_def (_IO_default_finish)
-_IO_off64_t
-_IO_default_seekoff (fp, offset, dir, mode)
- _IO_FILE *fp;
- _IO_off64_t offset;
- int dir;
- int mode;
+off64_t
+_IO_default_seekoff (FILE *fp, off64_t offset, int dir, int mode)
{
return _IO_pos_BAD;
}
int
-_IO_sputbackc (fp, c)
- _IO_FILE *fp;
- int c;
+_IO_sputbackc (FILE *fp, int c)
{
int result;
libc_hidden_def (_IO_sputbackc)
int
-_IO_sungetc (fp)
- _IO_FILE *fp;
+_IO_sungetc (FILE *fp)
{
int result;
return result;
}
-#if 0 /* Work in progress */
-/* Seems not to be needed. */
-#if 0
-void
-_IO_set_column (fp, c)
- _IO_FILE *fp;
- int c;
-{
- if (c == -1)
- fp->_column = -1;
- else
- fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
-}
-#else
-int
-_IO_set_column (fp, i)
- _IO_FILE *fp;
- int i;
-{
- fp->_cur_column = i + 1;
- return 0;
-}
-#endif
-#endif
-
-
unsigned
-_IO_adjust_column (start, line, count)
- unsigned start;
- const char *line;
- int count;
+_IO_adjust_column (unsigned start, const char *line, int count)
{
const char *ptr = line + count;
while (ptr > line)
}
libc_hidden_def (_IO_adjust_column)
-#if 0
-/* Seems not to be needed. --drepper */
-int
-_IO_get_column (fp)
- _IO_FILE *fp;
-{
- if (fp->_cur_column)
- return _IO_adjust_column (fp->_cur_column - 1,
- fp->_IO_write_base,
- fp->_IO_write_ptr - fp->_IO_write_base);
- return -1;
-}
-#endif
-
-
int
_IO_flush_all_lockp (int do_lock)
{
int result = 0;
- struct _IO_FILE *fp;
- int last_stamp;
+ FILE *fp;
#ifdef _IO_MTSAFE_IO
- __libc_cleanup_region_start (do_lock, flush_cleanup, NULL);
- if (do_lock)
- _IO_lock_lock (list_all_lock);
+ _IO_cleanup_region_start_noarg (flush_cleanup);
+ _IO_lock_lock (list_all_lock);
#endif
- last_stamp = _IO_list_all_stamp;
- fp = (_IO_FILE *) _IO_list_all;
- while (fp != NULL)
+ for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain)
{
run_fp = fp;
if (do_lock)
_IO_flockfile (fp);
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
-#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
-#endif
)
&& _IO_OVERFLOW (fp, EOF) == EOF)
result = EOF;
if (do_lock)
_IO_funlockfile (fp);
run_fp = NULL;
-
- if (last_stamp != _IO_list_all_stamp)
- {
- /* Something was added to the list. Start all over again. */
- fp = (_IO_FILE *) _IO_list_all;
- last_stamp = _IO_list_all_stamp;
- }
- else
- fp = fp->_chain;
}
#ifdef _IO_MTSAFE_IO
- if (do_lock)
- _IO_lock_unlock (list_all_lock);
- __libc_cleanup_region_end (0);
+ _IO_lock_unlock (list_all_lock);
+ _IO_cleanup_region_end (0);
#endif
return result;
int
-_IO_flush_all ()
+_IO_flush_all (void)
{
/* We want locking. */
return _IO_flush_all_lockp (1);
libc_hidden_def (_IO_flush_all)
void
-_IO_flush_all_linebuffered ()
+_IO_flush_all_linebuffered (void)
{
- struct _IO_FILE *fp;
- int last_stamp;
+ FILE *fp;
#ifdef _IO_MTSAFE_IO
_IO_cleanup_region_start_noarg (flush_cleanup);
_IO_lock_lock (list_all_lock);
#endif
- last_stamp = _IO_list_all_stamp;
- fp = (_IO_FILE *) _IO_list_all;
- while (fp != NULL)
+ for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain)
{
run_fp = fp;
_IO_flockfile (fp);
_IO_funlockfile (fp);
run_fp = NULL;
-
- if (last_stamp != _IO_list_all_stamp)
- {
- /* Something was added to the list. Start all over again. */
- fp = (_IO_FILE *) _IO_list_all;
- last_stamp = _IO_list_all_stamp;
- }
- else
- fp = fp->_chain;
}
#ifdef _IO_MTSAFE_IO
#endif
}
libc_hidden_def (_IO_flush_all_linebuffered)
-#ifdef _LIBC
weak_alias (_IO_flush_all_linebuffered, _flushlbf)
-#endif
/* The following is a bit tricky. In general, we want to unbuffer the
the atexit routine, just like _IO_cleanup. The problem is we do
not know whether the freeres code is called first or _IO_cleanup.
if the former is the case, we set the DEALLOC_BUFFER variable to
- true and _IO_unbuffer_write will take care of the rest. If
- _IO_unbuffer_write is called first we add the streams to a list
+ true and _IO_unbuffer_all will take care of the rest. If
+ _IO_unbuffer_all is called first we add the streams to a list
which the freeres function later can walk through. */
-static void _IO_unbuffer_write (void);
+static void _IO_unbuffer_all (void);
static bool dealloc_buffers;
-static _IO_FILE *freeres_list;
+static FILE *freeres_list;
static void
-_IO_unbuffer_write (void)
+_IO_unbuffer_all (void)
{
- struct _IO_FILE *fp;
- for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
+ FILE *fp;
+
+#ifdef _IO_MTSAFE_IO
+ _IO_cleanup_region_start_noarg (flush_cleanup);
+ _IO_lock_lock (list_all_lock);
+#endif
+
+ for (fp = (FILE *) _IO_list_all; fp; fp = fp->_chain)
{
if (! (fp->_flags & _IO_UNBUFFERED)
- && (! (fp->_flags & _IO_NO_WRITES)
- || (fp->_flags & _IO_IS_APPENDING))
/* Iff stream is un-orientated, it wasn't used. */
&& fp->_mode != 0)
{
fp->_freeres_list = freeres_list;
freeres_list = fp;
fp->_freeres_buf = fp->_IO_buf_base;
- fp->_freeres_size = _IO_blen (fp);
}
_IO_SETBUF (fp, NULL, 0);
+ if (fp->_mode > 0)
+ _IO_wsetb (fp, NULL, NULL, 0);
+
#ifdef _IO_MTSAFE_IO
if (cnt < MAXTRIES && fp->_lock != NULL)
_IO_lock_unlock (*fp->_lock);
used. */
fp->_mode = -1;
}
+
+#ifdef _IO_MTSAFE_IO
+ _IO_lock_unlock (list_all_lock);
+ _IO_cleanup_region_end (0);
+#endif
}
while (freeres_list != NULL)
{
- FREE_BUF (freeres_list->_freeres_buf, freeres_list->_freeres_size);
+ free (freeres_list->_freeres_buf);
freeres_list = freeres_list->_freeres_list;
}
int
-_IO_cleanup ()
+_IO_cleanup (void)
{
/* We do *not* want locking. Some threads might use streams but
that is their problem, we flush them underneath them. */
The following will make the standard streambufs be unbuffered,
which forces any output from late destructors to be written out. */
- _IO_unbuffer_write ();
+ _IO_unbuffer_all ();
return result;
}
void
-_IO_init_marker (marker, fp)
- struct _IO_marker *marker;
- _IO_FILE *fp;
+_IO_init_marker (struct _IO_marker *marker, FILE *fp)
{
marker->_sbuf = fp;
if (_IO_in_put_mode (fp))
}
void
-_IO_remove_marker (marker)
- struct _IO_marker *marker;
+_IO_remove_marker (struct _IO_marker *marker)
{
/* Unlink from sb's chain. */
struct _IO_marker **ptr = &marker->_sbuf->_markers;
return;
}
}
-#if 0
- if _sbuf has a backup area that is no longer needed, should we delete
- it now, or wait until the next underflow?
-#endif
+ /* FIXME: if _sbuf has a backup area that is no longer needed,
+ should we delete it now, or wait until the next underflow? */
}
#define BAD_DELTA EOF
int
-_IO_marker_difference (mark1, mark2)
- struct _IO_marker *mark1;
- struct _IO_marker *mark2;
+_IO_marker_difference (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
-_IO_marker_delta (mark)
- struct _IO_marker *mark;
+_IO_marker_delta (struct _IO_marker *mark)
{
int cur_pos;
if (mark->_sbuf == NULL)
}
int
-_IO_seekmark (fp, mark, delta)
- _IO_FILE *fp;
- struct _IO_marker *mark;
- int delta;
+_IO_seekmark (FILE *fp, struct _IO_marker *mark, int delta)
{
if (mark->_sbuf != fp)
return EOF;
}
void
-_IO_unsave_markers (fp)
- _IO_FILE *fp;
+_IO_unsave_markers (FILE *fp)
{
struct _IO_marker *mark = fp->_markers;
if (mark)
{
-#ifdef TODO
- streampos offset = seekoff (0, ios::cur, ios::in);
- if (offset != EOF)
- {
- offset += eGptr () - Gbase ();
- for ( ; mark != NULL; mark = mark->_next)
- mark->set_streampos (mark->_pos + offset);
- }
- else
- {
- for ( ; mark != NULL; mark = mark->_next)
- mark->set_streampos (EOF);
- }
-#endif
fp->_markers = 0;
}
}
libc_hidden_def (_IO_unsave_markers)
-#if 0
-/* Seems not to be needed. --drepper */
int
-_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;
-}
-#endif
-
-int
-_IO_default_pbackfail (fp, c)
- _IO_FILE *fp;
- int c;
+_IO_default_pbackfail (FILE *fp, int c)
{
if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
&& (unsigned char) fp->_IO_read_ptr[-1] == c)
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;
+ size_t new_size;
+ 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);
}
libc_hidden_def (_IO_default_pbackfail)
-_IO_off64_t
-_IO_default_seek (fp, offset, dir)
- _IO_FILE *fp;
- _IO_off64_t offset;
- int dir;
+off64_t
+_IO_default_seek (FILE *fp, off64_t offset, int dir)
{
return _IO_pos_BAD;
}
int
-_IO_default_stat (fp, st)
- _IO_FILE *fp;
- void* st;
+_IO_default_stat (FILE *fp, void *st)
{
return EOF;
}
-_IO_ssize_t
-_IO_default_read (fp, data, n)
- _IO_FILE* fp;
- void *data;
- _IO_ssize_t n;
+ssize_t
+_IO_default_read (FILE *fp, void *data, ssize_t n)
{
return -1;
}
-_IO_ssize_t
-_IO_default_write (fp, data, n)
- _IO_FILE *fp;
- const void *data;
- _IO_ssize_t n;
+ssize_t
+_IO_default_write (FILE *fp, const void *data, ssize_t n)
{
return 0;
}
int
-_IO_default_showmanyc (fp)
- _IO_FILE *fp;
+_IO_default_showmanyc (FILE *fp)
{
return -1;
}
void
-_IO_default_imbue (fp, locale)
- _IO_FILE *fp;
- void *locale;
+_IO_default_imbue (FILE *fp, void *locale)
{
}
_IO_ITER
-_IO_iter_begin()
+_IO_iter_begin (void)
{
return (_IO_ITER) _IO_list_all;
}
libc_hidden_def (_IO_iter_begin)
_IO_ITER
-_IO_iter_end()
+_IO_iter_end (void)
{
return NULL;
}
libc_hidden_def (_IO_iter_end)
_IO_ITER
-_IO_iter_next(iter)
- _IO_ITER iter;
+_IO_iter_next (_IO_ITER iter)
{
return iter->_chain;
}
libc_hidden_def (_IO_iter_next)
-_IO_FILE *
-_IO_iter_file(iter)
- _IO_ITER iter;
+FILE *
+_IO_iter_file (_IO_ITER iter)
{
return iter;
}
libc_hidden_def (_IO_iter_file)
void
-_IO_list_lock()
+_IO_list_lock (void)
{
#ifdef _IO_MTSAFE_IO
_IO_lock_lock (list_all_lock);
libc_hidden_def (_IO_list_lock)
void
-_IO_list_unlock()
+_IO_list_unlock (void)
{
#ifdef _IO_MTSAFE_IO
_IO_lock_unlock (list_all_lock);
libc_hidden_def (_IO_list_unlock)
void
-_IO_list_resetlock()
+_IO_list_resetlock (void)
{
#ifdef _IO_MTSAFE_IO
_IO_lock_init (list_all_lock);
}
libc_hidden_def (_IO_list_resetlock)
-
-#ifdef TODO
-#if defined(linux)
-#define IO_CLEANUP ;
-#endif
-
-#ifdef IO_CLEANUP
- IO_CLEANUP
-#else
-struct __io_defs {
- __io_defs() { }
- ~__io_defs() { _IO_cleanup (); }
-};
-__io_defs io_defs__;
-#endif
-
-#endif /* TODO */
-
-#ifdef text_set_element
text_set_element(__libc_atexit, _IO_cleanup);
-#endif
projects / thirdparty / glibc.git / blobdiff