Back to index

glibc  2.9
Defines | Functions | Variables
genops.c File Reference
#include "libioP.h"
#include <string.h>
#include <stdbool.h>

Go to the source code of this file.

Defines

#define MAXTRIES   2
#define BAD_DELTA   EOF

Functions

static void flush_cleanup (void *not_used)
void _IO_un_link (struct _IO_FILE_plus *fp)
void _IO_link_in (struct _IO_FILE_plus *fp)
_IO_ssize_t _IO_least_marker (_IO_FILE *fp, char *end_p)
void _IO_switch_to_main_get_area (_IO_FILE *fp)
void _IO_switch_to_backup_area (_IO_FILE *fp)
int _IO_switch_to_get_mode (_IO_FILE *fp)
void _IO_free_backup_area (_IO_FILE *fp)
int __overflow (_IO_FILE *f, int ch)
 libc_hidden_def (__overflow)
int __underflow (_IO_FILE *fp)
 libc_hidden_def (__underflow)
 libc_hidden_def (__uflow)
void _IO_doallocbuf (_IO_FILE *fp)
int _IO_default_underflow (_IO_FILE *fp)
int _IO_default_uflow (_IO_FILE *fp)
_IO_size_t _IO_default_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
_IO_size_t _IO_sgetn (_IO_FILE *fp, void *data, _IO_size_t n)
_IO_size_t _IO_default_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n)
_IO_FILE_IO_default_setbuf (_IO_FILE *fp, char *p, _IO_ssize_t len)
_IO_off64_t _IO_default_seekpos (_IO_FILE *fp, _IO_off64_t pos, int mode)
int _IO_default_doallocate (_IO_FILE *fp)
void _IO_init (_IO_FILE *fp, int flags)
void _IO_old_init (_IO_FILE *fp, int flags)
void _IO_no_init (_IO_FILE *fp, int flags, int orientation, struct _IO_wide_data *wd, const struct _IO_jump_t *jmp)
int _IO_default_sync (_IO_FILE *fp)
void _IO_default_finish (_IO_FILE *fp, int dummy)
_IO_off64_t _IO_default_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
int _IO_sputbackc (_IO_FILE *fp, int c)
int _IO_sungetc (_IO_FILE *fp)
unsigned _IO_adjust_column (unsigned start, const char *line, int count)
int _IO_flush_all_lockp (int do_lock)
int _IO_flush_all ()
void _IO_flush_all_linebuffered ()
static void _IO_unbuffer_write (void)
 libc_freeres_fn (buffer_free)
int _IO_cleanup ()
void _IO_init_marker (struct _IO_marker *marker, _IO_FILE *fp)
void _IO_remove_marker (struct _IO_marker *marker)
int _IO_marker_difference (struct _IO_marker *mark1, struct _IO_marker *mark2)
int _IO_marker_delta (struct _IO_marker *mark)
int _IO_seekmark (_IO_FILE *fp, struct _IO_marker *mark, int delta)
void _IO_unsave_markers (_IO_FILE *fp)
int _IO_default_pbackfail (_IO_FILE *fp, int c)
_IO_off64_t _IO_default_seek (_IO_FILE *fp, _IO_off64_t offset, int dir)
int _IO_default_stat (_IO_FILE *fp, void *st)
_IO_ssize_t _IO_default_read (_IO_FILE *fp, void *data, _IO_ssize_t n)
_IO_ssize_t _IO_default_write (_IO_FILE *fp, const void *data, _IO_ssize_t n)
int _IO_default_showmanyc (_IO_FILE *fp)
void _IO_default_imbue (_IO_FILE *fp, void *locale)
_IO_ITER _IO_iter_begin ()
 libc_hidden_def (_IO_iter_begin)
 libc_hidden_def (_IO_iter_end)
 libc_hidden_def (_IO_iter_next)
 libc_hidden_def (_IO_iter_file)
 libc_hidden_def (_IO_list_lock)
 libc_hidden_def (_IO_list_unlock)

Variables

static int _IO_list_all_stamp
static _IO_FILErun_fp
static bool dealloc_buffers
static _IO_FILEfreeres_list

Define Documentation

#define BAD_DELTA   EOF

Definition at line 1065 of file genops.c.

#define MAXTRIES   2

Function Documentation

int __overflow ( _IO_FILE f,
int  ch 
)

Definition at line 241 of file genops.c.

{
  /* This is a single-byte stream.  */
  if (f->_mode == 0)
    _IO_fwide (f, -1);
  return _IO_OVERFLOW (f, ch);
}

Here is the call graph for this function:

Definition at line 333 of file genops.c.

{
#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);
  if (_IO_in_put_mode (fp))
    if (INTUSE(_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))
    {
      _IO_switch_to_main_get_area (fp);
      if (fp->_IO_read_ptr < fp->_IO_read_end)
       return *(unsigned char *) fp->_IO_read_ptr;
    }
  if (_IO_have_markers (fp))
    {
      if (save_for_backup (fp, fp->_IO_read_end))
       return EOF;
    }
  else if (_IO_have_backup (fp))
    INTUSE(_IO_free_backup_area) (fp);
  return _IO_UNDERFLOW (fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned _IO_adjust_column ( unsigned  start,
const char *  line,
int  count 
)

Definition at line 793 of file genops.c.

{
  const char *ptr = line + count;
  while (ptr > line)
    if (*--ptr == '\n')
      return line + count - ptr - 1;
  return start + count;
}

Here is the caller graph for this function:

int _IO_cleanup ( void  )

Definition at line 1006 of file genops.c.

{
  /* We do *not* want locking.  Some threads might use streams but
     that is their problem, we flush them underneath them.  */
  int result = _IO_flush_all_lockp (0);

  /* We currently don't have a reliable mechanism for making sure that
     C++ static destructors are executed in the correct order.
     So it is possible that other static destructors might want to
     write to cout - and they're supposed to be able to do so.

     The following will make the standard streambufs be unbuffered,
     which forces any output from late destructors to be written out. */
  _IO_unbuffer_write ();

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 590 of file genops.c.

{
  char *buf;

  ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
  INTUSE(_IO_setb) (fp, buf, buf+_IO_BUFSIZ, 1);
  return 1;
}

Here is the call graph for this function:

void _IO_default_finish ( _IO_FILE fp,
int  dummy 
)

Definition at line 684 of file genops.c.

{
  struct _IO_marker *mark;
  if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
    {
      FREE_BUF (fp->_IO_buf_base, _IO_blen (fp));
      fp->_IO_buf_base = fp->_IO_buf_end = NULL;
    }

  for (mark = fp->_markers; mark != NULL; mark = mark->_next)
    mark->_sbuf = NULL;

  if (fp->_IO_save_base)
    {
      free (fp->_IO_save_base);
      fp->_IO_save_base = NULL;
    }

  INTUSE(_IO_un_link) ((struct _IO_FILE_plus *) fp);

#ifdef _IO_MTSAFE_IO
  if (fp->_lock != NULL)
    _IO_lock_fini (*fp->_lock);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _IO_default_imbue ( _IO_FILE fp,
void *  locale 
)

Definition at line 1259 of file genops.c.

{
}

Here is the caller graph for this function:

Definition at line 1158 of file genops.c.

{
  if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
      && (unsigned char) fp->_IO_read_ptr[-1] == c)
    --fp->_IO_read_ptr;
  else
    {
      /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
      if (!_IO_in_backup (fp))
       {
         /* We need to keep the invariant that the main get area
            logically follows the backup area.  */
         if (fp->_IO_read_ptr > fp->_IO_read_base && _IO_have_backup (fp))
           {
             if (save_for_backup (fp, fp->_IO_read_ptr))
              return EOF;
           }
         else 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;
           }
         fp->_IO_read_base = fp->_IO_read_ptr;
         _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 = c;
    }
  return (unsigned char) c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_IO_ssize_t _IO_default_read ( _IO_FILE fp,
void *  data,
_IO_ssize_t  n 
)

Definition at line 1234 of file genops.c.

{
  return -1;
}
_IO_off64_t _IO_default_seek ( _IO_FILE fp,
_IO_off64_t  offset,
int  dir 
)

Definition at line 1217 of file genops.c.

{
  return _IO_pos_BAD;
}
_IO_off64_t _IO_default_seekoff ( _IO_FILE fp,
_IO_off64_t  offset,
int  dir,
int  mode 
)

Definition at line 714 of file genops.c.

{
  return _IO_pos_BAD;
}

Definition at line 581 of file genops.c.

{
  return _IO_SEEKOFF (fp, pos, 0, mode);
}

Here is the caller graph for this function:

_IO_FILE* _IO_default_setbuf ( _IO_FILE fp,
char *  p,
_IO_ssize_t  len 
)

Definition at line 558 of file genops.c.

{
    if (_IO_SYNC (fp) == EOF)
       return NULL;
    if (p == NULL || len == 0)
      {
       fp->_flags |= _IO_UNBUFFERED;
       INTUSE(_IO_setb) (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
      }
    else
      {
       fp->_flags &= ~_IO_UNBUFFERED;
       INTUSE(_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;
    return fp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1252 of file genops.c.

{
  return -1;
}

Here is the caller graph for this function:

int _IO_default_stat ( _IO_FILE fp,
void*  st 
)

Definition at line 1226 of file genops.c.

{
  return EOF;
}

Definition at line 674 of file genops.c.

{
  return 0;
}

Definition at line 437 of file genops.c.

{
  int ch = _IO_UNDERFLOW (fp);
  if (ch == EOF)
    return EOF;
  return *(unsigned char *) fp->_IO_read_ptr++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 430 of file genops.c.

{
  return EOF;
}
_IO_ssize_t _IO_default_write ( _IO_FILE fp,
const void *  data,
_IO_ssize_t  n 
)

Definition at line 1243 of file genops.c.

{
  return 0;
}
_IO_size_t _IO_default_xsgetn ( _IO_FILE fp,
void *  data,
_IO_size_t  n 
)

Definition at line 505 of file genops.c.

{
  _IO_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;
         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)
           {
             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)
       break;
    }
  return n - more;
}

Here is the call graph for this function:

_IO_size_t _IO_default_xsputn ( _IO_FILE f,
const void *  data,
_IO_size_t  n 
)

Definition at line 448 of file genops.c.

{
  const char *s = (char *) data;
  _IO_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;
         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;
             for (i = count; --i >= 0; )
              *p++ = *s++;
             f->_IO_write_ptr = p;
            }
         more -= count;
        }
      if (more == 0 || _IO_OVERFLOW (f, (unsigned char) *s++) == EOF)
       break;
      more--;
    }
  return n - more;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _IO_doallocbuf ( _IO_FILE fp)

Definition at line 417 of file genops.c.

{
  if (fp->_IO_buf_base)
    return;
  if (!(fp->_flags & _IO_UNBUFFERED) || fp->_mode > 0)
    if (_IO_DOALLOCATE (fp) != EOF)
      return;
  INTUSE(_IO_setb) (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int _IO_flush_all ( void  )

Definition at line 877 of file genops.c.

{
  /* We want locking.  */
  return _IO_flush_all_lockp (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _IO_flush_all_linebuffered ( void  )

Definition at line 885 of file genops.c.

{
  struct _IO_FILE *fp;
  int last_stamp;

#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 *) INTUSE(_IO_list_all);
  while (fp != NULL)
    {
      run_fp = fp;
      _IO_flockfile (fp);

      if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
       _IO_OVERFLOW (fp, EOF);

      _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 *) INTUSE(_IO_list_all);
         last_stamp = _IO_list_all_stamp;
       }
      else
       fp = fp->_chain;
    }

#ifdef _IO_MTSAFE_IO
  _IO_lock_unlock (list_all_lock);
  _IO_cleanup_region_end (0);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

int _IO_flush_all_lockp ( int  do_lock)

Definition at line 822 of file genops.c.

{
  int result = 0;
  struct _IO_FILE *fp;
  int last_stamp;

#ifdef _IO_MTSAFE_IO
  _IO_cleanup_region_start_noarg (flush_cleanup);
  if (do_lock)
    _IO_lock_lock (list_all_lock);
#endif

  last_stamp = _IO_list_all_stamp;
  fp = (_IO_FILE *) INTUSE(_IO_list_all);
  while (fp != NULL)
    {
      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 *) INTUSE(_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);
  _IO_cleanup_region_end (0);
#endif

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 209 of file genops.c.

{
  if (_IO_in_backup (fp))
    _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;
  fp->_IO_backup_base = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _IO_init ( _IO_FILE fp,
int  flags 
)

Definition at line 602 of file genops.c.

{
  _IO_no_init (fp, flags, -1, NULL, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _IO_init_marker ( struct _IO_marker marker,
_IO_FILE fp 
)

Definition at line 1026 of file genops.c.

{
  marker->_sbuf = fp;
  if (_IO_in_put_mode (fp))
    INTUSE(_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;

  /* Should perhaps sort the chain? */
  marker->_next = fp->_markers;
  fp->_markers = marker;
}

Here is the call graph for this function:

Definition at line 1266 of file genops.c.

{
  return (_IO_ITER) INTUSE(_IO_list_all);
}

Here is the caller graph for this function:

_IO_ssize_t _IO_least_marker ( _IO_FILE fp,
char *  end_p 
)

Definition at line 132 of file genops.c.

{
  _IO_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)
      least_so_far = mark->_pos;
  return least_so_far;
}

Here is the caller graph for this function:

void _IO_link_in ( struct _IO_FILE_plus fp)

Definition at line 102 of file genops.c.

{
  if ((fp->file._flags & _IO_LINKED) == 0)
    {
      fp->file._flags |= _IO_LINKED;
#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);
#endif
      fp->file._chain = (_IO_FILE *) INTUSE(_IO_list_all);
      INTUSE(_IO_list_all) = fp;
      ++_IO_list_all_stamp;
#ifdef _IO_MTSAFE_IO
      _IO_funlockfile ((_IO_FILE *) fp);
      run_fp = NULL;
      _IO_lock_unlock (list_all_lock);
      _IO_cleanup_region_end (0);
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int _IO_marker_delta ( struct _IO_marker mark)

Definition at line 1077 of file genops.c.

{
  int cur_pos;
  if (mark->_sbuf == NULL)
    return BAD_DELTA;
  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;
  return mark->_pos - cur_pos;
}
int _IO_marker_difference ( struct _IO_marker mark1,
struct _IO_marker mark2 
)

Definition at line 1068 of file genops.c.

{
  return mark1->_pos - mark2->_pos;
}
void _IO_no_init ( _IO_FILE fp,
int  flags,
int  orientation,
struct _IO_wide_data *  wd,
const struct _IO_jump_t jmp 
)

Definition at line 642 of file genops.c.

{
  _IO_old_init (fp, flags);
  fp->_mode = orientation;
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
  if (orientation >= 0)
    {
      fp->_wide_data = wd;
      fp->_wide_data->_IO_buf_base = NULL;
      fp->_wide_data->_IO_buf_end = NULL;
      fp->_wide_data->_IO_read_base = NULL;
      fp->_wide_data->_IO_read_ptr = NULL;
      fp->_wide_data->_IO_read_end = NULL;
      fp->_wide_data->_IO_write_base = NULL;
      fp->_wide_data->_IO_write_ptr = NULL;
      fp->_wide_data->_IO_write_end = NULL;
      fp->_wide_data->_IO_save_base = NULL;
      fp->_wide_data->_IO_backup_base = NULL;
      fp->_wide_data->_IO_save_end = NULL;

      fp->_wide_data->_wide_vtable = jmp;
    }
#endif
  fp->_freeres_list = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _IO_old_init ( _IO_FILE fp,
int  flags 
)

Definition at line 611 of file genops.c.

{
  fp->_flags = _IO_MAGIC|flags;
  fp->_flags2 = 0;
  fp->_IO_buf_base = NULL;
  fp->_IO_buf_end = NULL;
  fp->_IO_read_base = NULL;
  fp->_IO_read_ptr = NULL;
  fp->_IO_read_end = NULL;
  fp->_IO_write_base = NULL;
  fp->_IO_write_ptr = NULL;
  fp->_IO_write_end = NULL;
  fp->_chain = NULL; /* Not necessary. */

  fp->_IO_save_base = NULL;
  fp->_IO_backup_base = NULL;
  fp->_IO_save_end = NULL;
  fp->_markers = NULL;
  fp->_cur_column = 0;
#if _IO_JUMPS_OFFSET
  fp->_vtable_offset = 0;
#endif
#ifdef _IO_MTSAFE_IO
  if (fp->_lock != NULL)
    _IO_lock_init (*fp->_lock);
#endif
}

Here is the caller graph for this function:

void _IO_remove_marker ( struct _IO_marker marker)

Definition at line 1044 of file genops.c.

{
  /* Unlink from sb's chain. */
  struct _IO_marker **ptr = &marker->_sbuf->_markers;
  for (; ; ptr = &(*ptr)->_next)
    {
      if (*ptr == NULL)
       break;
      else if (*ptr == marker)
       {
         *ptr = marker->_next;
         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
}

Here is the call graph for this function:

int _IO_seekmark ( _IO_FILE fp,
struct _IO_marker mark,
int  delta 
)

Definition at line 1091 of file genops.c.

{
  if (mark->_sbuf != fp)
    return EOF;
 if (mark->_pos >= 0)
    {
      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);
      fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
    }
  return 0;
}

Here is the call graph for this function:

_IO_size_t _IO_sgetn ( _IO_FILE fp,
void *  data,
_IO_size_t  n 
)

Definition at line 494 of file genops.c.

{
  /* FIXME handle putback buffer here! */
  return _IO_XSGETN (fp, data, n);
}

Here is the caller graph for this function:

int _IO_sputbackc ( _IO_FILE fp,
int  c 
)

Definition at line 724 of file genops.c.

{
  int result;

  if (fp->_IO_read_ptr > fp->_IO_read_base
      && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
    {
      fp->_IO_read_ptr--;
      result = (unsigned char) c;
    }
  else
    result = _IO_PBACKFAIL (fp, c);

  if (result != EOF)
    fp->_flags &= ~_IO_EOF_SEEN;

  return result;
}

Here is the caller graph for this function:

Definition at line 747 of file genops.c.

{
  int result;

  if (fp->_IO_read_ptr > fp->_IO_read_base)
    {
      fp->_IO_read_ptr--;
      result = (unsigned char) *fp->_IO_read_ptr;
    }
  else
    result = _IO_PBACKFAIL (fp, EOF);

  if (result != EOF)
    fp->_flags &= ~_IO_EOF_SEEN;

  return result;
}

Definition at line 167 of file genops.c.

{
  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;
  /* 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;
  /* Set _IO_read_ptr.  */
  fp->_IO_read_ptr = fp->_IO_read_end;
}

Here is the caller graph for this function:

Definition at line 185 of file genops.c.

{
  if (fp->_IO_write_ptr > fp->_IO_write_base)
    if (_IO_OVERFLOW (fp, EOF) == EOF)
      return EOF;
  if (_IO_in_backup (fp))
    fp->_IO_read_base = fp->_IO_backup_base;
  else
    {
      fp->_IO_read_base = fp->_IO_buf_base;
      if (fp->_IO_write_ptr > fp->_IO_read_end)
       fp->_IO_read_end = fp->_IO_write_ptr;
    }
  fp->_IO_read_ptr = fp->_IO_write_ptr;

  fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;

  fp->_flags &= ~_IO_CURRENTLY_PUTTING;
  return 0;
}

Here is the caller graph for this function:

Definition at line 147 of file genops.c.

{
  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;
  /* 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;
  /* Set _IO_read_ptr. */
  fp->_IO_read_ptr = fp->_IO_read_base;
}

Here is the caller graph for this function:

void _IO_un_link ( struct _IO_FILE_plus fp)

Definition at line 62 of file genops.c.

{
  if (fp->file._flags & _IO_LINKED)
    {
      struct _IO_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);
#endif
      if (INTUSE(_IO_list_all) == NULL)
       ;
      else if (fp == INTUSE(_IO_list_all))
       {
         INTUSE(_IO_list_all)
           = (struct _IO_FILE_plus *) INTUSE(_IO_list_all)->file._chain;
         ++_IO_list_all_stamp;
       }
      else
       for (f = &INTUSE(_IO_list_all)->file._chain; *f; f = &(*f)->_chain)
         if (*f == (_IO_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);
      run_fp = NULL;
      _IO_lock_unlock (list_all_lock);
      _IO_cleanup_region_end (0);
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void _IO_unbuffer_write ( void  ) [static]

Definition at line 948 of file genops.c.

{
  struct _IO_FILE *fp;
  for (fp = (_IO_FILE *) INTUSE(_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)
       {
         int cnt;
#define MAXTRIES 2
         for (cnt = 0; cnt < MAXTRIES; ++cnt)
           if (_IO_lock_trylock (*fp->_lock) == 0)
             break;
           else
             /* Give the other thread time to finish up its use of the
               stream.  */
             __sched_yield ();

         if (! dealloc_buffers && !(fp->_flags & _IO_USER_BUF))
           {
             fp->_flags |= _IO_USER_BUF;

             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 (cnt < MAXTRIES)
           _IO_lock_unlock (*fp->_lock);
       }

      /* Make sure that never again the wide char functions can be
        used.  */
      fp->_mode = -1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _IO_unsave_markers ( _IO_FILE fp)

Definition at line 1114 of file genops.c.

{
  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;
    }

  if (_IO_have_backup (fp))
    INTUSE(_IO_free_backup_area) (fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void flush_cleanup ( void *  not_used) [static]

Definition at line 52 of file genops.c.

{
  if (run_fp != NULL)
    _IO_funlockfile (run_fp);
#ifdef _IO_MTSAFE_IO
  _IO_lock_unlock (list_all_lock);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

libc_freeres_fn ( buffer_free  )

Definition at line 992 of file genops.c.

{
  dealloc_buffers = true;

  while (freeres_list != NULL)
    {
      FREE_BUF (freeres_list->_freeres_buf, freeres_list->_freeres_size);

      freeres_list = freeres_list->_freeres_list;
    }
}

Definition at line 250 of file genops.c.

{
  /* Append [_IO_read_base..end_p] to backup area. */
  _IO_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;
  /* 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;
  struct _IO_marker *mark;
  if (needed_size > current_Bsize)
    {
      char *new_buffer;
      avail = 100;
      new_buffer = (char *) malloc (avail + needed_size);
      if (new_buffer == NULL)
       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,
              fp->_IO_read_base + least_mark,
              needed_size);
      free (fp->_IO_save_base);
      fp->_IO_save_base = new_buffer;
      fp->_IO_save_end = new_buffer + avail + needed_size;
    }
  else
    {
      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,
                end_p - fp->_IO_read_base);
       }
      else if (needed_size > 0)
       memcpy (fp->_IO_save_base + avail,
              fp->_IO_read_base + least_mark,
              needed_size);
    }
  fp->_IO_backup_base = fp->_IO_save_base + avail;
  /* Adjust all the streammarkers. */
  delta = end_p - fp->_IO_read_base;
  for (mark = fp->_markers; mark != NULL; mark = mark->_next)
    mark->_pos -= delta;
  return 0;
}

Here is the call graph for this function:

Definition at line 363 of file genops.c.

{
#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);
  if (_IO_in_put_mode (fp))
    if (INTUSE(_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))
    {
      _IO_switch_to_main_get_area (fp);
      if (fp->_IO_read_ptr < fp->_IO_read_end)
       return *(unsigned char *) fp->_IO_read_ptr++;
    }
  if (_IO_have_markers (fp))
    {
      if (save_for_backup (fp, fp->_IO_read_end))
       return EOF;
    }
  else if (_IO_have_backup (fp))
    INTUSE(_IO_free_backup_area) (fp);
  return _IO_UFLOW (fp);
}

Here is the call graph for this function:

Definition at line 396 of file genops.c.

{
  if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
    FREE_BUF (f->_IO_buf_base, _IO_blen (f));
  f->_IO_buf_base = b;
  f->_IO_buf_end = eb;
  if (a)
    f->_flags &= ~_IO_USER_BUF;
  else
    f->_flags |= _IO_USER_BUF;
}

Definition at line 1270 of file genops.c.

{
  return NULL;
}
libc_hidden_def ( _IO_iter_end  )

Definition at line 1277 of file genops.c.

{
  return iter->_chain;
}
libc_hidden_def ( _IO_iter_next  )

Definition at line 1285 of file genops.c.

{
  return iter;
}
libc_hidden_def ( _IO_iter_file  )

Definition at line 1293 of file genops.c.

{
#ifdef _IO_MTSAFE_IO
  _IO_lock_lock (list_all_lock);
#endif
}
libc_hidden_def ( _IO_list_lock  )

Definition at line 1302 of file genops.c.

{
#ifdef _IO_MTSAFE_IO
  _IO_lock_unlock (list_all_lock);
#endif
}
libc_hidden_def ( _IO_list_unlock  )

Definition at line 1311 of file genops.c.

{
#ifdef _IO_MTSAFE_IO
  _IO_lock_init (list_all_lock);
#endif
}

Variable Documentation

Definition at line 46 of file genops.c.

bool dealloc_buffers [static]

Definition at line 944 of file genops.c.

Definition at line 945 of file genops.c.

_IO_FILE* run_fp [static]

Definition at line 49 of file genops.c.