Return to filebuf.c CVS log

Up to [Research Unix] / researchv8dc / cmd / cfront / libC / stream

Annotation of researchv8dc/cmd/cfront/libC/stream/filebuf.c, revision 1.1

1.1     ! root        1: #include "stream.h"
        !             2: 
        !             3: /* define some UNIX calls */
        !             4: extern int open (char *, int);
        !             5: extern int close (int);
        !             6: extern long lseek (int, long, int);
        !             7: extern int read (int, char *, unsigned);
        !             8: extern int write (int, char *, unsigned);
        !             9: extern int creat (char *, int);
        !            10: 
        !            11: /*
        !            12:  *     Open a file with the given mode.
        !            13:  *     Return:         NULL if failure
        !            14:  *                     this if success
        !            15:  */
        !            16: filebuf* filebuf.open (char *name, open_mode om)
        !            17: {
        !            18:        switch (om) {
        !            19:        case input:     
        !            20:                fd = ::open(name, 0);
        !            21:                break;
        !            22:        case output:    
        !            23:                if ((fd = ::open(name,1)) < 0) fd = creat(name, 664);
        !            24:                break;
        !            25:        case append:    
        !            26:                if ((fd = ::open(name,1)) < 0)
        !            27:                        fd = creat(name, 664);
        !            28:                else {
        !            29:                        if (lseek(fd, 0, 2) < 0) {
        !            30:                                (void)::close(fd);
        !            31:                                fd = -1;
        !            32:                        }
        !            33:                }
        !            34:                break;
        !            35:        }
        !            36: 
        !            37:        if (fd < 0) return NULL;
        !            38: 
        !            39:        opened = 1;
        !            40:        return this;
        !            41: }
        !            42: 
        !            43: /*
        !            44:  *     Empty an output buffer.
        !            45:  *     Returns:        EOF on error
        !            46:  *                     0 on success
        !            47:  */
        !            48: int filebuf.overflow(int c)
        !            49: {
        !            50:        if (!opened || allocate()==EOF) return EOF;
        !            51: 
        !            52:        if (base == eptr) {
        !            53:                /* unbuffered IO */
        !            54:                if (c != EOF) {
        !            55:                        *pptr = c;
        !            56:                        if (write(fd, pptr, 1) != 1) return EOF;
        !            57:                }
        !            58:        } else {
        !            59:                /* buffered IO */
        !            60:                if (pptr > base)
        !            61:                        if (write(fd, base, pptr-base) != pptr-base) return EOF;
        !            62:                pptr = gptr = base;
        !            63:                if (c != EOF) *pptr++ = c;
        !            64:        }
        !            65:        return c & 0377;
        !            66: }
        !            67: 
        !            68: /*
        !            69:  *     Fill an input buffer.
        !            70:  *     Returns:        EOF on error or end of input
        !            71:  *                     next character on success
        !            72:  */
        !            73: int filebuf.underflow()
        !            74: {
        !            75:        int count;
        !            76: 
        !            77:        if (!opened || allocate()==EOF) return EOF;
        !            78: 
        !            79:        if ((count=read(fd, base, eptr-base)) < 1) return EOF;
        !            80: 
        !            81:        gptr = base;
        !            82:        pptr = base + count;
        !            83:        return *gptr & 0377;
        !            84: }

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