Return to strstream.cc CVS log

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

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

1.1     ! root        1: /* This is part of libio/iostream, providing -*- C++ -*- input/output.
        !             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: /* Written by Per Bothner ([email protected]). */
        !            26: 
        !            27: #ifdef __GNUG__
        !            28: #pragma implementation
        !            29: #endif
        !            30: #include "iostreamP.h"
        !            31: #include "strstream.h"
        !            32: #include <string.h>
        !            33: 
        !            34: static void* default_alloc(_IO_size_t size)
        !            35: {
        !            36:     return (void*)new char[size];
        !            37: }
        !            38: 
        !            39: static void default_free(void* ptr)
        !            40: {
        !            41:     delete [] (char*)ptr;
        !            42: }
        !            43: 
        !            44: /* Set to use the _IO_str_jump jumptable, for efficiency */
        !            45: 
        !            46: #define SET_STR_JUMPS(STRBUF) \
        !            47:   (STRBUF)->_jumps = &_IO_str_jumps,\
        !            48:   (STRBUF)->_vtable() = NULL;
        !            49: 
        !            50: istrstream::istrstream(const char *cp, int n)
        !            51: {
        !            52:   init(new strstreambuf(cp, n));
        !            53:   SET_STR_JUMPS(_strbuf);
        !            54: }
        !            55: 
        !            56: ostrstream::ostrstream()
        !            57: {
        !            58:   init(new strstreambuf());
        !            59:   SET_STR_JUMPS(_strbuf);
        !            60: }
        !            61: 
        !            62: strstreambase::strstreambase(char *cp, int n, int mode)
        !            63: {
        !            64:   char *pstart;
        !            65:   if (mode == ios::app || mode == ios::ate)
        !            66:     pstart = cp + strlen(cp);
        !            67:   else
        !            68:     pstart = cp;
        !            69:   init(new strstreambuf(cp, n, pstart));
        !            70:   SET_STR_JUMPS(_strbuf);
        !            71: }
        !            72: 
        !            73: char *strstreambuf::str()
        !            74: {
        !            75:     freeze(1);
        !            76:     return base();
        !            77: }
        !            78: 
        !            79: _IO_ssize_t strstreambuf::pcount() { return _IO_str_count (this); }
        !            80: 
        !            81: int strstreambuf::overflow(int c /* = EOF */)
        !            82: {
        !            83:   return _IO_str_overflow (this, c);
        !            84: }
        !            85: 
        !            86: int strstreambuf::underflow()
        !            87: {
        !            88:   return _IO_str_underflow(this);
        !            89: }
        !            90: 
        !            91: 
        !            92: void strstreambuf::init_dynamic(_IO_alloc_type alloc, _IO_free_type free,
        !            93:                                int initial_size)
        !            94:                                
        !            95: {
        !            96:     _s._len = 0;
        !            97:     if (initial_size < 16)
        !            98:        initial_size = 16;
        !            99:     _s._allocate_buffer = alloc ? alloc : default_alloc;
        !           100:     _s._free_buffer = free ? free : default_free;
        !           101:     char * buf = (char*)(*_s._allocate_buffer)(initial_size);
        !           102:     setb(buf, buf + initial_size, 1);
        !           103:     setp(buf, buf + initial_size);
        !           104:     setg(buf, buf, buf);
        !           105: }
        !           106: 
        !           107: void strstreambuf::init_static(char *ptr, int size, char *pstart)
        !           108: {
        !           109:   _IO_str_init_static (this, ptr, size, pstart);
        !           110: }
        !           111: 
        !           112: void strstreambuf::init_readonly (const char *ptr, int size)
        !           113: {
        !           114:   _IO_str_init_readonly (this, ptr, size);
        !           115: }
        !           116: 
        !           117: strstreambuf::~strstreambuf()
        !           118: {
        !           119:     if (_IO_buf_base && !(_flags & _IO_USER_BUF))
        !           120:         (_s._free_buffer)(_IO_buf_base);
        !           121:     _IO_buf_base = NULL;
        !           122: }
        !           123: 
        !           124: streampos strstreambuf::seekoff(streamoff off, _seek_dir dir,
        !           125:                                        int mode /*=ios::in|ios::out*/)
        !           126: {
        !           127:   return _IO_str_seekoff (this, off, convert_to_seekflags(dir, mode));
        !           128: }
        !           129: 
        !           130: int strstreambuf::pbackfail(int c)
        !           131: {
        !           132:   return _IO_str_pbackfail (this, c);
        !           133: }

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