Return to fwrite.c CVS log

Up to [Research Unix] / researchv10dc / libI77 / notused

Annotation of researchv10dc/libI77/notused/fwrite.c, revision 1.1

1.1     ! root        1: /*     @(#)fwrite.c    3.6     */
        !             2: /*LINTLIBRARY*/
        !             3: /*
        !             4:  * This version writes directly to the buffer rather than looping on putc.
        !             5:  * Ptr args aren't checked for NULL because the program would be a
        !             6:  * catastrophic mess anyway.  Better to abort than just to return NULL.
        !             7:  *
        !             8:  * This version does buffered writes larger than BUFSIZ directly, when
        !             9:  * the buffer is empty.
        !            10:  */
        !            11: #include <stdio.h>
        !            12: #include "stdiom.h"
        !            13: 
        !            14: #define MIN(x, y)       (x < y ? x : y)
        !            15: 
        !            16: extern char *memcpy();
        !            17: 
        !            18: int
        !            19: fwrite(ptr, size, count, iop)
        !            20: char *ptr;
        !            21: int size, count;
        !            22: register FILE *iop;
        !            23: {
        !            24:        register unsigned nleft;
        !            25:        register int n;
        !            26:        register unsigned char *cptr, *bufend;
        !            27: 
        !            28:        if (size <= 0 || count <= 0 || _WRTCHK(iop))
        !            29:                return (0);
        !            30: 
        !            31:        bufend = _bufend(iop);
        !            32:        nleft = count*size;
        !            33: 
        !            34:        /* if the file is unbuffered, or if the iop->ptr = iop->base, and there
        !            35:           is > BUFSZ chars to write, we can do a direct write */
        !            36:        if (iop->_base >= iop->_ptr)  { /*this covers the unbuffered case, too*/
        !            37:                if (((iop->_flag & _IONBF) != 0) || (nleft >= BUFSIZ))  {
        !            38:                        if ((n=write(fileno(iop),ptr,nleft)) != nleft)
        !            39:                            {
        !            40:                                iop->_flag |= _IOERR;
        !            41:                                n = (n >= 0) ? n : 0;
        !            42:                        }
        !            43:                        return n/size;
        !            44:                }
        !            45:        }
        !            46:        /* Put characters in the buffer */
        !            47:        /* note that the meaning of n when just starting this loop is
        !            48:           irrelevant.  It is defined in the loop */
        !            49:        for (; ; ptr += n) {
        !            50:                while ((n = bufend - (cptr = iop->_ptr)) <= 0)  /* full buf */
        !            51:                        if (_xflsbuf(iop) == EOF)
        !            52:                                return (count - (nleft + size - 1)/size);
        !            53:                n = MIN(nleft, n);
        !            54:                (void) memcpy((char *) cptr, ptr, n);
        !            55:                iop->_cnt -= n;
        !            56:                iop->_ptr += n;
        !            57:                _BUFSYNC(iop);
        !            58:                /* done; flush if linebuffered with a newline */
        !            59:                if ((nleft -= n) == 0)  { 
        !            60:                        if (iop->_flag & (_IOLBF | _IONBF)) {
        !            61:                                if ((iop->_flag & _IONBF) || (memchr(iop->_base,
        !            62:                                        '\n',count * size) != NULL))  {
        !            63:                                        (void) _xflsbuf(iop);
        !            64:                                }
        !            65:                        }
        !            66:                        return (count);
        !            67:                }
        !            68:        }
        !            69: }

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