toolchain/gcc/newlib/libc/stdio/setvbuf.c

   1 /*
   2  * Copyright (c) 1990 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that the above copyright notice and this paragraph are
   7  * duplicated in all such forms and that any documentation,
   8  * advertising materials, and other materials related to such
   9  * distribution and use acknowledge that the software was developed
  10  * by the University of California, Berkeley.  The name of the
  11  * University may not be used to endorse or promote products derived
  12  * from this software without specific prior written permission.
  13  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  */
  17
  18 /*
  19 FUNCTION
  20 <<setvbuf>>---specify file or stream buffering
  21
  22 INDEX
  23         setvbuf
  24
  25 ANSI_SYNOPSIS
  26         #include <stdio.h>
  27         int setvbuf(FILE *<[fp]>, char *<[buf]>,
  28                     int <[mode]>, size_t <[size]>);
  29
  30 TRAD_SYNOPSIS
  31         #include <stdio.h>
  32         int setvbuf(<[fp]>, <[buf]>, <[mode]>, <[size]>)
  33         FILE *<[fp]>;
  34         char *<[buf]>;
  35         int <[mode]>;
  36         size_t <[size]>;
  37
  38 DESCRIPTION
  39 Use <<setvbuf>> to specify what kind of buffering you want for the
  40 file or stream identified by <[fp]>, by using one of the following
  41 values (from <<stdio.h>>) as the <[mode]> argument:
  42
  43 o+
  44 o _IONBF
  45 Do not use a buffer: send output directly to the host system for the
  46 file or stream identified by <[fp]>.
  47
  48 o _IOFBF
  49 Use full output buffering: output will be passed on to the host system
  50 only when the buffer is full, or when an input operation intervenes.
  51
  52 o _IOLBF
  53 Use line buffering: pass on output to the host system at every
  54 newline, as well as when the buffer is full, or when an input
  55 operation intervenes.
  56 o-
  57
  58 Use the <[size]> argument to specify how large a buffer you wish.  You
  59 can supply the buffer itself, if you wish, by passing a pointer to a
  60 suitable area of memory as <[buf]>.  Otherwise, you may pass <<NULL>>
  61 as the <[buf]> argument, and <<setvbuf>> will allocate the buffer.
  62
  63 WARNINGS
  64 You may only use <<setvbuf>> before performing any file operation other
  65 than opening the file.
  66
  67 If you supply a non-null <[buf]>, you must ensure that the associated
  68 storage continues to be available until you close the stream
  69 identified by <[fp]>.
  70
  71 RETURNS
  72 A <<0>> result indicates success, <<EOF>> failure (invalid <[mode]> or
  73 <[size]> can cause failure).
  74
  75 PORTABILITY
  76 Both ANSI C and the System V Interface Definition (Issue 2) require
  77 <<setvbuf>>. However, they differ on the meaning of a <<NULL>> buffer
  78 pointer: the SVID issue 2 specification says that a <<NULL>> buffer
  79 pointer requests unbuffered output.  For maximum portability, avoid
  80 <<NULL>> buffer pointers.
  81
  82 Both specifications describe the result on failure only as a
  83 nonzero value.
  84
  85 Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
  86 <<lseek>>, <<read>>, <<sbrk>>, <<write>>.
  87 */
  88
  89 #include <_ansi.h>
  90 #include <stdio.h>
  91 #include <stdlib.h>
  92 #include "local.h"
  93
  94 /*
  95  * Set one of the three kinds of buffering, optionally including a buffer.
  96  */
  97
  98 int
  99 _DEFUN (setvbuf, (fp, buf, mode, size),
 100         register FILE * fp _AND
 101         char *buf _AND
 102         register int mode _AND
 103         register size_t size)
 104 {
 105   int ret = 0;
 106
 107   _flockfile(fp);
 108
 109   CHECK_INIT (fp);
 110
 111   /*
 112    * Verify arguments.  The `int' limit on `size' is due to this
 113    * particular implementation.
 114    */
 115
 116   if ((mode != _IOFBF && mode != _IOLBF && mode != _IONBF) || (int)(_POINTER_INT) size < 0)
 117     {
 118       _funlockfile(fp);
 119       return (EOF);
 120     }
 121
 122   /*
 123    * Write current buffer, if any; drop read count, if any.
 124    * Make sure putc() will not think fp is line buffered.
 125    * Free old buffer if it was from malloc().  Clear line and
 126    * non buffer flags, and clear malloc flag.
 127    */
 128
 129   (void) fflush (fp);
 130   fp->_r = 0;
 131   fp->_lbfsize = 0;
 132   if (fp->_flags & __SMBF)
 133     _free_r (_REENT, (void *) fp->_bf._base);
 134   fp->_flags &= ~(__SLBF | __SNBF | __SMBF);
 135
 136   if (mode == _IONBF)
 137     goto nbf;
 138
 139   /*
 140    * Allocate buffer if needed. */
 141   if (buf == NULL)
 142     {
 143       /* we need this here because malloc() may return a pointer
 144          even if size == 0 */
 145       if (!size) size = BUFSIZ;
 146       if ((buf = malloc (size)) == NULL)
 147         {
 148           ret = EOF;
 149           /* Try another size... */
 150           buf = malloc (BUFSIZ);
 151           size = BUFSIZ;
 152         }
 153       if (buf == NULL)
 154         {
 155           /* Can't allocate it, let's try another approach */
 156 nbf:
 157           fp->_flags |= __SNBF;
 158           fp->_w = 0;
 159           fp->_bf._base = fp->_p = fp->_nbuf;
 160           fp->_bf._size = 1;
 161           _funlockfile(fp);
 162           return (ret);
 163         }
 164       fp->_flags |= __SMBF;
 165     }
 166   /*
 167    * Now put back whichever flag is needed, and fix _lbfsize
 168    * if line buffered.  Ensure output flush on exit if the
 169    * stream will be buffered at all.
 170    * If buf is NULL then make _lbfsize 0 to force the buffer
 171    * to be flushed and hence malloced on first use
 172    */
 173
 174   switch (mode)
 175     {
 176     case _IOLBF:
 177       fp->_flags |= __SLBF;
 178       fp->_lbfsize = buf ? -size : 0;
 179       /* FALLTHROUGH */
 180
 181     case _IOFBF:
 182       /* no flag */
 183       _REENT->__cleanup = _cleanup_r;
 184       fp->_bf._base = fp->_p = (unsigned char *) buf;
 185       fp->_bf._size = size;
 186       break;
 187     }
 188
 189   /*
 190    * Patch up write count if necessary.
 191    */
 192
 193   if (fp->_flags & __SWR)
 194     fp->_w = fp->_flags & (__SLBF | __SNBF) ? 0 : size;
 195
 196   _funlockfile(fp);
 197   return 0;
 198 }