Return to fstream.h CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / libC / oiostream

Annotation of researchv10no/cmd/cfront/libC/oiostream/fstream.h, revision 1.1

1.1     ! root        1: /*ident        "@(#)ctrans:incl/fstream.h      1.1.1.2" */
        !             2: /**************************************************************************
        !             3:                         Copyright (c) 1984 AT&T
        !             4:                           All Rights Reserved   
        !             5: 
        !             6:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
        !             7:       
        !             8:         The copyright notice above does not evidence any        
        !             9:         actual or intended publication of such source code.
        !            10: 
        !            11: *****************************************************************************/
        !            12: #ifndef FSTREAMH
        !            13: #define FSTREAMH
        !            14: 
        !            15: #include <iostream.h>
        !            16: 
        !            17: class  filebuf : public streambuf {    /* a stream buffer for files */
        !            18: public:
        !            19:        static const int openprot ; /* default protection for open */
        !            20: public:
        !            21:                        filebuf() ;
        !            22:                        filebuf(int fd);
        !            23:                        filebuf(int fd, char*  p, int l) ;
        !            24: 
        !            25:        int             is_open() { return opened ; }
        !            26:        int             fd() { return xfd ; }
        !            27:        filebuf*        open(const char *name, int om, int prot=openprot);
        !            28:        filebuf*        attach(int fd) ;
        !            29:        filebuf*        close() ;
        !            30:                        ~filebuf() ;
        !            31: public: /* virtuals */
        !            32:        virtual int     overflow(int=EOF);
        !            33:        virtual int     underflow();
        !            34:        virtual int     sync() ;
        !            35:        virtual streampos
        !            36:                        seekoff(streamoff,seek_dir,int) ;
        !            37:        virtual streambuf*
        !            38:                        setbuf(char*  p, int len) ;
        !            39: protected:
        !            40:        int             xfd;    
        !            41:        int             mode ;
        !            42:        char            opened;
        !            43:        streampos       last_seek ;
        !            44:        char*           in_start;
        !            45:        int             last_op();
        !            46:        char            lahead[2] ;
        !            47: };
        !            48: 
        !            49: class fstreambase : virtual public ios { 
        !            50: public:
        !            51:                        fstreambase() ;
        !            52:        
        !            53:                        fstreambase(const char* name, 
        !            54:                                        int mode,
        !            55:                                        int prot=filebuf::openprot) ;
        !            56:                        fstreambase(int fd) ;
        !            57:                        fstreambase(int fd, char*  p, int l) ;
        !            58:                        ~fstreambase() ;
        !            59:        void            open(const char* name, int mode, 
        !            60:                                        int prot=filebuf::openprot) ;
        !            61:        void            attach(int fd);
        !            62:        void            close() ;
        !            63:        void            setbuf(char*  p, int l) ;
        !            64:        filebuf*        rdbuf() { return &buf ; }
        !            65: private:
        !            66:        filebuf         buf ;
        !            67: protected:
        !            68:        void            verify(int) ;
        !            69: } ;
        !            70: 
        !            71: class ifstream : public fstreambase, public istream {
        !            72: public:
        !            73:                        ifstream() ;
        !            74:                        ifstream(const char* name, 
        !            75:                                        int mode=ios::in,
        !            76:                                        int prot=filebuf::openprot) ;
        !            77:                        ifstream(int fd) ;
        !            78:                        ifstream(int fd, char*  p, int l) ;
        !            79:                        ~ifstream() ;
        !            80: 
        !            81:        filebuf*        rdbuf() { return fstreambase::rdbuf(); }
        !            82:        void            open(const char* name, int mode=ios::in, 
        !            83:                                        int prot=filebuf::openprot) ;
        !            84: } ;
        !            85: 
        !            86: class ofstream : public fstreambase, public ostream {
        !            87: public:
        !            88:                        ofstream() ;
        !            89:                        ofstream(const char* name, 
        !            90:                                        int mode=ios::out,
        !            91:                                        int prot=filebuf::openprot) ;
        !            92:                        ofstream(int fd) ;
        !            93:                        ofstream(int fd, char*  p, int l) ;
        !            94:                        ~ofstream() ;
        !            95: 
        !            96:        filebuf*        rdbuf() { return fstreambase::rdbuf(); }
        !            97:        void            open(const char* name, int mode=ios::out, 
        !            98:                                        int prot=filebuf::openprot) ;
        !            99: } ;
        !           100: 
        !           101: class fstream : public fstreambase, public iostream {
        !           102: public:
        !           103:                        fstream() ;
        !           104:        
        !           105:                        fstream(const char* name, 
        !           106:                                        int mode,
        !           107:                                        int prot=filebuf::openprot) ;
        !           108:                        fstream(int fd) ;
        !           109:                        fstream(int fd, char*  p, int l) ;
        !           110:                        ~fstream() ;
        !           111:        filebuf*        rdbuf() { return fstreambase::rdbuf(); }
        !           112:        void            open(const char* name, int mode, 
        !           113:                                int prot=filebuf::openprot) ;
        !           114: } ;
        !           115: 
        !           116: #endif

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