Return to stdiobuf.c CVS log

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

Annotation of researchv10no/cmd/cfront/libC/ooiostream/stdiobuf.c, revision 1.1.1.1

1.1       root        1: /*ident        "@(#)ctrans:lib/stream/stdiobuf.c       1.1.2.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: stdiobuf.c:
                     12: 
                     13: *****************************************************************************/
                     14: 
                     15: 
                     16: #include <iostream.h>
                     17: #include <stdiostream.h>
                     18: 
                     19: int stdiobuf::overflow(int c) 
                     20: {
                     21:        if ( fp == 0 || c==EOF) return EOF ;
                     22:        if ( last_op == ios::in ) {
                     23:                if ( egptr()!=gptr() ) ungetc(*gptr(),fp) ;
                     24:                // stdio requires seeks between reads and writes
                     25:                fseek(fp,0,ios::cur) ;
                     26:                setg(0,0,0) ;
                     27:                }
                     28:        last_op = ios::out ;
                     29:        
                     30:        return putc(c,fp) ;
                     31: }
                     32: 
                     33: int stdiobuf::underflow() {
                     34:        if ( fp == 0 ) return EOF ;
                     35:        if ( last_op == ios::out ) {
                     36:                fseek(fp,0,0) ;
                     37:                }
                     38:        if ( feof(fp) ) return EOF ;
                     39:        int c = getc(fp) ;
                     40:        if ( c == EOF ) return EOF ;
                     41:        setg(buf,buf,buf+1) ;
                     42:        buf[0] = c ;
                     43:        return c ;
                     44: }
                     45: 
                     46: int stdiobuf::pbackfail(int c) 
                     47: {
                     48:        return ungetc(c,fp) ;
                     49: }
                     50: 
                     51: int stdiobuf::sync()
                     52: {
                     53:        if ( last_op==ios::out ) fflush(fp) ;
                     54:        else if ( last_op==ios::in && gptr()!=egptr() ) {
                     55:                ungetc(*gptr(),fp) ;
                     56:                setg(0,0,0) ;
                     57:        }
                     58:        return fseek(fp,0,ios::cur) ;
                     59: }
                     60:        
                     61: streampos stdiobuf::seekoff(streamoff p,seek_dir d,open_mode) 
                     62: {
                     63: 
                     64:        if ( gptr()!=egptr() ) ungetc(*gptr(),fp) ;
                     65:        setg(0,0,0) ;
                     66:        return fseek(fp,p,d) ;
                     67: }
                     68: 
                     69: stdiobuf::stdiobuf(FILE* f) :
                     70:        fp(f)
                     71: {
                     72:        setbuf((char*)0,0) ;
                     73: }
                     74: 
                     75: stdiobuf::~stdiobuf() 
                     76: {
                     77:        if (fp) fflush(fp) ;
                     78: }
                     79: 
                     80: stdiostream::stdiostream(FILE* f) :  buf(f)
                     81: {
                     82:        init(&buf) ;
                     83: }
                     84: 
                     85: stdiostream::~stdiostream() { }
                     86: 
                     87: stdiobuf* stdiostream::rdbuf() { return &buf ; }

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