Back to index

glibc  2.9
Defines | Functions
iosetvbuf.c File Reference
#include "libioP.h"

Go to the source code of this file.

Defines

#define _IOFBF   0 /* Fully buffered. */
#define _IOLBF   1 /* Line buffered. */
#define _IONBF   2 /* No buffering. */

Functions

int _IO_setvbuf (_IO_FILE *fp, char *buf, int mode, _IO_size_t size)

Define Documentation

#define _IOFBF   0 /* Fully buffered. */

Definition at line 31 of file iosetvbuf.c.

#define _IOLBF   1 /* Line buffered. */

Definition at line 32 of file iosetvbuf.c.

#define _IONBF   2 /* No buffering. */

Definition at line 33 of file iosetvbuf.c.


Function Documentation

int _IO_setvbuf ( _IO_FILE fp,
char *  buf,
int  mode,
_IO_size_t  size 
)

Definition at line 36 of file iosetvbuf.c.

{
  int result;
  CHECK_FILE (fp, EOF);
  _IO_acquire_lock (fp);
  switch (mode)
    {
    case _IOFBF:
      fp->_IO_file_flags &= ~(_IO_LINE_BUF|_IO_UNBUFFERED);
      if (buf == NULL)
       {
         if (fp->_IO_buf_base == NULL)
           {
             /* There is no flag to distinguish between "fully buffered
               mode has been explicitly set" as opposed to "line
               buffering has not been explicitly set".  In both
               cases, _IO_LINE_BUF is off.  If this is a tty, and
               _IO_filedoalloc later gets called, it cannot know if
               it should set the _IO_LINE_BUF flag (because that is
               the default), or not (because we have explicitly asked
               for fully buffered mode).  So we make sure a buffer
               gets allocated now, and explicitly turn off line
               buffering.

               A possibly cleaner alternative would be to add an
               extra flag, but then flags are a finite resource.  */
             if (_IO_DOALLOCATE (fp) < 0)
              {
                result = EOF;
                goto unlock_return;
              }
             fp->_IO_file_flags &= ~_IO_LINE_BUF;
           }
         result = 0;
         goto unlock_return;
       }
      break;
    case _IOLBF:
      fp->_IO_file_flags &= ~_IO_UNBUFFERED;
      fp->_IO_file_flags |= _IO_LINE_BUF;
      if (buf == NULL)
       {
         result = 0;
         goto unlock_return;
       }
      break;
    case _IONBF:
      fp->_IO_file_flags &= ~_IO_LINE_BUF;
      fp->_IO_file_flags |= _IO_UNBUFFERED;
      buf = NULL;
      size = 0;
      break;
    default:
      result = EOF;
      goto unlock_return;
    }
  result = _IO_SETBUF (fp, buf, size) == NULL ? EOF : 0;

unlock_return:
  _IO_release_lock (fp);
  return result;
}

Here is the caller graph for this function: