Return to setvbuf.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / XSTDIO

Annotation of coherent/b/lib/libc/XSTDIO/setvbuf.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * libc/stdio/setvbuf.c
        !             3:  * ANSI-compliant C standard i/o library.
        !             4:  * setvbuf()
        !             5:  * ANSI 4.9.5.6.
        !             6:  * Set i/o buffer.
        !             7:  */
        !             8: 
        !             9: #include <stdio.h>
        !            10: #include <stdlib.h>
        !            11: 
        !            12: /*
        !            13:  * The get and put function pointers in a FILE
        !            14:  * initially contain &_fginit() and &_fpinit().
        !            15:  * The buffering characteristics of the stream
        !            16:  * are determined either by an explicit setvbuf()
        !            17:  * before the first get or put on the stream
        !            18:  * or by a setvbuf() call from finit() on the first get or put.
        !            19:  * setvbuf() allocates a buffer if necessary and
        !            20:  * initializes various fields in the FILE.
        !            21:  *
        !            22:  * For unbuffered streams, _cc == 0 and _bp == _cp == _dp == _ep == NULL.
        !            23:  * For buffered streams:
        !            24:  *     _cc == 0        nothing is buffered
        !            25:  *     _cc > 0         _cc input or output characters are buffered
        !            26:  *     _bp             base of buffer
        !            27:  *     _cp             current buffer pointer
        !            28:  *     _dp             data pointer
        !            29:  *     _ep             end of buffer pointer
        !            30:  * The old version of the stdio functions used
        !            31:  *     _cc < 0         -(_cc) input characters are buffered
        !            32:  *     _cc > 0         _cc output characters are buffered
        !            33:  * which makes much more sense but is unfortunately not compatible with
        !            34:  * the Unix version of stdio.h.  This stdio gets very confused if you
        !            35:  * mix input and output calls without fflush() in between on a rw stream;
        !            36:  * this is non-ANSI compliant but works right with the old version.
        !            37:  */
        !            38: int
        !            39: setvbuf(stream, buf, mode, size) register FILE *stream; char *buf; int mode; size_t size;
        !            40: {
        !            41:        register _FILE2 *f2p;
        !            42: 
        !            43: #if    _ASCII
        !            44:        register int isascii;
        !            45: 
        !            46:        isascii = stream->_ff2 & _FASCII;
        !            47: #endif
        !            48: 
        !            49:        if (stream->_mode != _MODE_UNINIT)
        !            50:                return 1;                       /* Mode assigned, failure */
        !            51: 
        !            52:        /* Allocate a buffer if necessary. */
        !            53:        if (mode != _IONBF && buf == NULL) {
        !            54:                if ((buf = malloc(size)) == NULL)
        !            55:                        return 1;               /* Buffer allocation failure */
        !            56:                stream->_ff2 |= _FFREEB;        /* Free buffer when closed */
        !            57:        }
        !            58: 
        !            59:        f2p = stream->_f2p;
        !            60:        switch(mode) {
        !            61: 
        !            62:        case _IOFBF:                            /* Fully buffered. */
        !            63:                stream->_ff1 |= _IOFBF;
        !            64:                stream->_mode = _MODE_FBUF;
        !            65: #if    _ASCII
        !            66:                f2p->_pt = isascii ? &_fputba : &_fputb;
        !            67: #else
        !            68:                f2p->_pt = &_fputb;
        !            69: #endif
        !            70:                f2p->_dp = stream->_cp = buf + boffset(stream, size);
        !            71:        lab:
        !            72: #if    _ASCII
        !            73:                f2p->_gt = isascii ? &_fgetba : &_fgetb;
        !            74: #else
        !            75:                f2p->_gt = &_fgetb;
        !            76: #endif
        !            77:                f2p->_bp = buf;
        !            78:                f2p->_ep = buf + size;
        !            79:                break;
        !            80: 
        !            81:        case _IOLBF:                            /* Line buffered */
        !            82:                stream->_ff1 |= _IOLBF;
        !            83:                stream->_mode = _MODE_LBUF;
        !            84: #if    _ASCII
        !            85:                f2p->_pt = isascii ? &_fputta : &_fputt;
        !            86: #else
        !            87:                f2p->_pt = &_fputt;
        !            88: #endif
        !            89:                f2p->_dp = stream->_cp = buf;
        !            90:                goto lab;
        !            91: 
        !            92:        case _IONBF:                            /* Unbuffered */
        !            93:                stream->_ff1 |= _IONBF;
        !            94:                stream->_mode = _MODE_NBUF;
        !            95: #if    _ASCII
        !            96:                f2p->_gt = isascii ? &_fgetca : &_fgetc;
        !            97:                f2p->_pt = isascii ? &_fputca : &_fputc;
        !            98: #else
        !            99:                f2p->_gt = &_fgetc;
        !           100:                f2p->_pt = &_fputc;
        !           101: #endif
        !           102:                break;
        !           103: 
        !           104:        default:                                /* Unrecognized mode */
        !           105:                return 1;
        !           106:        }
        !           107: 
        !           108:        if (stream->_ff1 & _FWONLY)
        !           109:                f2p->_gt = &_fgete;
        !           110:        if (stream->_ff1 & _FRONLY)
        !           111:                f2p->_pt = &_fpute;
        !           112:        stream->_cc = 0;
        !           113:        return 0;                               /* Success */
        !           114: }
        !           115: 
        !           116: /*
        !           117:  * Return the current offset of a stream.
        !           118:  * This is an attempt to keep buffered file i/o properly aligned.
        !           119:  * For example, a 200 byte file opened in append mode with a
        !           120:  * default buffer size of 512 bytes will have boffset 200
        !           121:  * and subsequent write()s will hopefully occur at 512-byte boundaries.
        !           122:  * If the user calls setvbuf() explicitly with a strange buffer size
        !           123:  * (not a multiple of the size for optimum disk i/o),
        !           124:  * the user will get degraded performance.
        !           125:  */
        !           126: static
        !           127: int
        !           128: boffset(fp, size) register FILE *fp; register size_t size;
        !           129: {
        !           130:        register long offset;
        !           131: 
        !           132:        if ((offset=lseek(fileno(fp), 0L, SEEK_CUR)) == -1L || size == 0)
        !           133:                return 0;
        !           134:        return (unsigned)offset%(unsigned)size;
        !           135: }
        !           136: 
        !           137: /* end of libc/stdio/setvbuf.c */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.