Return to filebuf.c CVS log

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

Annotation of researchv9/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:                fd = creat(name, 0664);
        !            24:                break;
        !            25:        case append:    
        !            26:                fd = ::open(name, 1);
        !            27:                if (fd < 0) fd = creat(name, 0664);
        !            28:                if (fd >= 0) (void)lseek(fd, 0, 2);
        !            29:                break;
        !            30:        }
        !            31: 
        !            32:        if (fd < 0) return NULL;
        !            33: 
        !            34:        opened = 1;
        !            35:        return this;
        !            36: }
        !            37: 
        !            38: /*
        !            39:  *     Empty an output buffer.
        !            40:  *     Returns:        EOF on error
        !            41:  *                     0 on success
        !            42:  */
        !            43: int filebuf::overflow(int c)
        !            44: {
        !            45:        if (!opened || allocate()==EOF) return EOF;
        !            46: 
        !            47:        if (fp != NULL) {               // stdio compatibility
        !            48:                fflush(fp);
        !            49:                return 0;
        !            50:        }
        !            51:        else if (base == eptr) {        // unbuffered IO
        !            52:                if (c != EOF) {
        !            53:                        *pptr = c;
        !            54:                        if (write(fd, pptr, 1) != 1) return EOF;
        !            55:                }
        !            56:        }
        !            57:        else {                          // buffered IO
        !            58:                if (pptr > base)
        !            59:                        if (write(fd, base, pptr-base) != pptr-base) return EOF;
        !            60:                pptr = gptr = base;
        !            61:                if (c != EOF) *pptr++ = c;
        !            62:        }
        !            63:        return c & 0377;
        !            64: }
        !            65: 
        !            66: /*
        !            67:  *     Fill an input buffer.
        !            68:  *     Returns:        EOF on error or end of input
        !            69:  *                     next character on success
        !            70:  */
        !            71: int filebuf::underflow()
        !            72: {
        !            73:        int count;
        !            74:        extern int strlen(char *);
        !            75: 
        !            76:        if (!opened || allocate()==EOF) return EOF;
        !            77: 
        !            78:        if (fp!=NULL) {                 // stdio compatibility
        !            79:                if (fgets(base+1, eptr-base-1, fp) == NULL) return EOF;
        !            80:                count = strlen(base+1);
        !            81:        }
        !            82:        else {                          // normal stream io
        !            83:                if ((count=read(fd, base+1, eptr-base-1)) < 1) return EOF;
        !            84:        }
        !            85:        gptr = base+1;                  // leave room for putback
        !            86:        pptr = gptr+count;
        !            87:        return *gptr & 0377;
        !            88: }

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