Return to builtinbuf.cc CVS log

Up to [Apple XNU] / GNUtools / libg++ / libio

Annotation of GNUtools/libg++/libio/builtinbuf.cc, revision 1.1

1.1     ! root        1: /* 
        !             2: Copyright (C) 1993 Free Software Foundation
        !             3: 
        !             4: This file is part of the GNU IO Library.  This library is free
        !             5: software; you can redistribute it and/or modify it under the
        !             6: terms of the GNU General Public License as published by the
        !             7: Free Software Foundation; either version 2, or (at your option)
        !             8: any later version.
        !             9: 
        !            10: This library is distributed in the hope that it will be useful,
        !            11: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13: GNU General Public License for more details.
        !            14: 
        !            15: You should have received a copy of the GNU General Public License
        !            16: along with GNU CC; see the file COPYING.  If not, write to
        !            17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
        !            18: 
        !            19: As a special exception, if you link this library with files
        !            20: compiled with a GNU compiler to produce an executable, this does not cause
        !            21: the resulting executable to be covered by the GNU General Public License.
        !            22: This exception does not however invalidate any other reasons why
        !            23: the executable file might be covered by the GNU General Public License. */
        !            24: 
        !            25: #ifdef __GNUC__
        !            26: #pragma implementation
        !            27: #endif
        !            28: 
        !            29: #include "builtinbuf.h"
        !            30: #include "iostreamP.h"
        !            31: 
        !            32: int builtinbuf::overflow(int ch) { return (*_jumps->__overflow)(this, ch); }
        !            33: 
        !            34: int builtinbuf::underflow() { return (*_jumps->__underflow)(this); }
        !            35: 
        !            36: streamsize builtinbuf::xsgetn(char* buf, streamsize n)
        !            37: { return (*_jumps->__xsgetn)(this, buf, n); }
        !            38: 
        !            39: streamsize builtinbuf::xsputn(const char* buf, streamsize n)
        !            40: { return _jumps->__xsputn (this, buf, n); }
        !            41: 
        !            42: int builtinbuf::doallocate() { return _jumps->__doallocate(this); }
        !            43: 
        !            44: builtinbuf::~builtinbuf() { _jumps->__finish(this); }
        !            45: 
        !            46: int builtinbuf::sync() { return _jumps->__sync(this); }
        !            47: 
        !            48: streambuf* builtinbuf::setbuf(char *buf, int n)
        !            49: { return _jumps->__setbuf (this, buf, n) == 0 ? this : NULL; }
        !            50: 
        !            51: streampos builtinbuf::seekoff(streamoff off, _seek_dir dir, int mode)
        !            52: {
        !            53:   return _jumps->__seekoff (this, off, convert_to_seekflags(dir, mode));
        !            54: }
        !            55: 
        !            56: streampos builtinbuf::seekpos(streampos pos, int mode)
        !            57: {
        !            58:   int flags = 0;
        !            59:   if (!(mode & ios::in))
        !            60:     flags |= _IO_seek_not_in;
        !            61:   if (!(mode & ios::out))
        !            62:     flags |= _IO_seek_not_out;
        !            63:   return _jumps->__seekpos(this, pos, (_IO_seekflags)flags);
        !            64: }
        !            65: 
        !            66: int builtinbuf::pbackfail(int c)
        !            67: { return _jumps->__pbackfail(this, c); }
        !            68: 
        !            69: streamsize builtinbuf::sys_read(char* buf, streamsize size)
        !            70: { return _jumps->__read(this, buf, size); }
        !            71: 
        !            72: streampos builtinbuf::sys_seek(streamoff off, _seek_dir dir)
        !            73: { return _jumps->__seek(this, off, dir); }
        !            74: 
        !            75: streamsize builtinbuf::sys_write(const char* buf, streamsize size)
        !            76: { return _jumps->__write(this, buf, size); }
        !            77: 
        !            78: int builtinbuf::sys_stat(void* buf) // Actually, a (struct stat*)
        !            79: { return _jumps->__stat(this, buf); }
        !            80: 
        !            81: int builtinbuf::sys_close()
        !            82: { return _jumps->__close(this); }
        !            83: 
        !            84: const void *builtinbuf::vtable = NULL;
        !            85: 
        !            86: void ios::_IO_fix_vtable() const
        !            87: {
        !            88:   if (builtinbuf::vtable == NULL)
        !            89:     {
        !            90:       char _dummy[sizeof(builtinbuf)];
        !            91:       ((builtinbuf*)_dummy)->builtinbuf::builtinbuf();
        !            92:       builtinbuf::vtable = ((builtinbuf*)_dummy)->_vtable();
        !            93:     }
        !            94:   /* Cast away constness.  Maybe we should use the new 'mutable' keyword. */
        !            95:   ((ios*)this)->_strbuf->_vtable() = builtinbuf::vtable;
        !            96: }
        !            97: 
        !            98: /* This method is TEMPORARY, for binary compatibility! */
        !            99: void ios::_IO_fix_vtable()
        !           100: {
        !           101:   ((const ios*) this)->_IO_fix_vtable();
        !           102: }

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