From fb21a4dfe2c81640379f64855509fb7613530887 Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Wed, 9 Sep 2015 22:43:35 +0200 Subject: Removed wrongly added coverage report --- rep/usr/include/c++/4.3/streambuf.gcov.html | 871 ---------------------------- 1 file changed, 871 deletions(-) delete mode 100644 rep/usr/include/c++/4.3/streambuf.gcov.html (limited to 'rep/usr/include/c++/4.3/streambuf.gcov.html') diff --git a/rep/usr/include/c++/4.3/streambuf.gcov.html b/rep/usr/include/c++/4.3/streambuf.gcov.html deleted file mode 100644 index f3d6dee..0000000 --- a/rep/usr/include/c++/4.3/streambuf.gcov.html +++ /dev/null @@ -1,871 +0,0 @@ - - - - - - - LCOV - lcov.info - /usr/include/c++/4.3/streambuf - - - - - - - - - - - - - -
LTP GCOV extension - code coverage report
- - - - - - - - - - - - - - - - - - - - - - - -
Current view:directory - usr/include/c++/4.3 - streambuf
Test:lcov.info
Date:2008-08-14Instrumented lines:36
Code covered:0.0 %Executed lines:0
-
- - - - - - - - - 

-       1                 : // Stream buffer classes -*- C++ -*-
-       2                 : 
-       3                 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-       4                 : // 2006, 2007, 2008 Free Software Foundation, Inc.
-       5                 : //
-       6                 : // This file is part of the GNU ISO C++ Library.  This library is free
-       7                 : // software; you can redistribute it and/or modify it under the
-       8                 : // terms of the GNU General Public License as published by the
-       9                 : // Free Software Foundation; either version 2, or (at your option)
-      10                 : // any later version.
-      11                 : 
-      12                 : // This library is distributed in the hope that it will be useful,
-      13                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
-      14                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-      15                 : // GNU General Public License for more details.
-      16                 : 
-      17                 : // You should have received a copy of the GNU General Public License
-      18                 : // along with this library; see the file COPYING.  If not, write to
-      19                 : // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-      20                 : // Boston, MA 02110-1301, USA.
-      21                 : 
-      22                 : // As a special exception, you may use this file as part of a free software
-      23                 : // library without restriction.  Specifically, if other files instantiate
-      24                 : // templates or use macros or inline functions from this file, or you compile
-      25                 : // this file and link it with other files to produce an executable, this
-      26                 : // file does not by itself cause the resulting executable to be covered by
-      27                 : // the GNU General Public License.  This exception does not however
-      28                 : // invalidate any other reasons why the executable file might be covered by
-      29                 : // the GNU General Public License.
-      30                 : 
-      31                 : /** @file streambuf
-      32                 :  *  This is a Standard C++ Library header.
-      33                 :  */
-      34                 : 
-      35                 : //
-      36                 : // ISO C++ 14882: 27.5  Stream buffers
-      37                 : //
-      38                 : 
-      39                 : #ifndef _GLIBXX_STREAMBUF
-      40                 : #define _GLIBXX_STREAMBUF 1
-      41                 : 
-      42                 : #pragma GCC system_header
-      43                 : 
-      44                 : #include <bits/c++config.h>
-      45                 : #include <iosfwd>
-      46                 : #include <bits/localefwd.h>
-      47                 : #include <bits/ios_base.h>
-      48                 : #include <bits/cpp_type_traits.h>
-      49                 : #include <ext/type_traits.h>
-      50                 : 
-      51                 : _GLIBCXX_BEGIN_NAMESPACE(std)
-      52                 : 
-      53                 :   template<typename _CharT, typename _Traits>
-      54                 :     streamsize
-      55                 :     __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
-      56                 :                           basic_streambuf<_CharT, _Traits>*, bool&);
-      57                 : 
-      58                 :   /**
-      59                 :    *  @brief  The actual work of input and output (interface).
-      60                 :    *
-      61                 :    *  This is a base class.  Derived stream buffers each control a
-      62                 :    *  pair of character sequences:  one for input, and one for output.
-      63                 :    *
-      64                 :    *  Section [27.5.1] of the standard describes the requirements and
-      65                 :    *  behavior of stream buffer classes.  That section (three paragraphs)
-      66                 :    *  is reproduced here, for simplicity and accuracy.
-      67                 :    *
-      68                 :    *  -# Stream buffers can impose various constraints on the sequences
-      69                 :    *     they control.  Some constraints are:
-      70                 :    *     - The controlled input sequence can be not readable.
-      71                 :    *     - The controlled output sequence can be not writable.
-      72                 :    *     - The controlled sequences can be associated with the contents of
-      73                 :    *       other representations for character sequences, such as external
-      74                 :    *       files.
-      75                 :    *     - The controlled sequences can support operations @e directly to or
-      76                 :    *       from associated sequences.
-      77                 :    *     - The controlled sequences can impose limitations on how the
-      78                 :    *       program can read characters from a sequence, write characters to
-      79                 :    *       a sequence, put characters back into an input sequence, or alter
-      80                 :    *       the stream position.
-      81                 :    *     .
-      82                 :    *  -# Each sequence is characterized by three pointers which, if non-null,
-      83                 :    *     all point into the same @c charT array object.  The array object
-      84                 :    *     represents, at any moment, a (sub)sequence of characters from the
-      85                 :    *     sequence.  Operations performed on a sequence alter the values
-      86                 :    *     stored in these pointers, perform reads and writes directly to or
-      87                 :    *     from associated sequences, and alter "the stream position" and
-      88                 :    *     conversion state as needed to maintain this subsequence relationship.
-      89                 :    *     The three pointers are:
-      90                 :    *     - the <em>beginning pointer</em>, or lowest element address in the
-      91                 :    *       array (called @e xbeg here);
-      92                 :    *     - the <em>next pointer</em>, or next element address that is a
-      93                 :    *       current candidate for reading or writing (called @e xnext here);
-      94                 :    *     - the <em>end pointer</em>, or first element address beyond the
-      95                 :    *       end of the array (called @e xend here).
-      96                 :    *     .
-      97                 :    *  -# The following semantic constraints shall always apply for any set
-      98                 :    *     of three pointers for a sequence, using the pointer names given
-      99                 :    *     immediately above:
-     100                 :    *     - If @e xnext is not a null pointer, then @e xbeg and @e xend shall
-     101                 :    *       also be non-null pointers into the same @c charT array, as
-     102                 :    *       described above; otherwise, @e xbeg and @e xend shall also be null.
-     103                 :    *     - If @e xnext is not a null pointer and @e xnext < @e xend for an
-     104                 :    *       output sequence, then a <em>write position</em> is available.
-     105                 :    *       In this case, @e *xnext shall be assignable as the next element
-     106                 :    *       to write (to put, or to store a character value, into the sequence).
-     107                 :    *     - If @e xnext is not a null pointer and @e xbeg < @e xnext for an
-     108                 :    *       input sequence, then a <em>putback position</em> is available.
-     109                 :    *       In this case, @e xnext[-1] shall have a defined value and is the
-     110                 :    *       next (preceding) element to store a character that is put back
-     111                 :    *       into the input sequence.
-     112                 :    *     - If @e xnext is not a null pointer and @e xnext< @e xend for an
-     113                 :    *       input sequence, then a <em>read position</em> is available.
-     114                 :    *       In this case, @e *xnext shall have a defined value and is the
-     115                 :    *       next element to read (to get, or to obtain a character value,
-     116                 :    *       from the sequence).
-     117                 :   */
-     118                 :   template<typename _CharT, typename _Traits>
-     119                 :     class basic_streambuf 
-     120                 :     {
-     121                 :     public:
-     122                 :       //@{
-     123                 :       /**
-     124                 :        *  These are standard types.  They permit a standardized way of
-     125                 :        *  referring to names of (or names dependant on) the template
-     126                 :        *  parameters, which are specific to the implementation.
-     127                 :       */
-     128                 :       typedef _CharT                                    char_type;
-     129                 :       typedef _Traits                                   traits_type;
-     130                 :       typedef typename traits_type::int_type            int_type;
-     131                 :       typedef typename traits_type::pos_type            pos_type;
-     132                 :       typedef typename traits_type::off_type            off_type;
-     133                 :       //@}
-     134                 : 
-     135                 :       //@{
-     136                 :       /// This is a non-standard type.
-     137                 :       typedef basic_streambuf<char_type, traits_type>     __streambuf_type;
-     138                 :       //@}
-     139                 :       
-     140                 :       friend class basic_ios<char_type, traits_type>;
-     141                 :       friend class basic_istream<char_type, traits_type>;
-     142                 :       friend class basic_ostream<char_type, traits_type>;
-     143                 :       friend class istreambuf_iterator<char_type, traits_type>;
-     144                 :       friend class ostreambuf_iterator<char_type, traits_type>;
-     145                 : 
-     146                 :       friend streamsize
-     147                 :       __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);
-     148                 : 
-     149                 :       template<bool _IsMove, typename _CharT2>
-     150                 :         friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, 
-     151                 :                                                _CharT2*>::__type
-     152                 :         __copy_move_a2(istreambuf_iterator<_CharT2>,
-     153                 :                        istreambuf_iterator<_CharT2>, _CharT2*);
-     154                 : 
-     155                 :       template<typename _CharT2>
-     156                 :         friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
-     157                 :                                   istreambuf_iterator<_CharT2> >::__type
-     158                 :         find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
-     159                 :              const _CharT2&);
-     160                 : 
-     161                 :       template<typename _CharT2, typename _Traits2>
-     162                 :         friend basic_istream<_CharT2, _Traits2>&
-     163                 :         operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
-     164                 : 
-     165                 :       template<typename _CharT2, typename _Traits2, typename _Alloc>
-     166                 :         friend basic_istream<_CharT2, _Traits2>&
-     167                 :         operator>>(basic_istream<_CharT2, _Traits2>&,
-     168                 :                    basic_string<_CharT2, _Traits2, _Alloc>&);
-     169                 : 
-     170                 :       template<typename _CharT2, typename _Traits2, typename _Alloc>
-     171                 :         friend basic_istream<_CharT2, _Traits2>&
-     172                 :         getline(basic_istream<_CharT2, _Traits2>&,
-     173                 :                 basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
-     174                 : 
-     175                 :     protected:
-     176                 :       //@{
-     177                 :       /**
-     178                 :        *  This is based on _IO_FILE, just reordered to be more consistent,
-     179                 :        *  and is intended to be the most minimal abstraction for an
-     180                 :        *  internal buffer.
-     181                 :        *  -  get == input == read
-     182                 :        *  -  put == output == write
-     183                 :       */
-     184                 :       char_type*                _M_in_beg;     // Start of get area. 
-     185                 :       char_type*                _M_in_cur;     // Current read area. 
-     186                 :       char_type*                _M_in_end;     // End of get area. 
-     187                 :       char_type*                _M_out_beg;    // Start of put area. 
-     188                 :       char_type*                _M_out_cur;    // Current put area. 
-     189                 :       char_type*                _M_out_end;    // End of put area.
-     190                 : 
-     191                 :       /// Current locale setting.
-     192                 :       locale                    _M_buf_locale;  
-     193                 : 
-     194                 :   public:
-     195                 :       /// Destructor deallocates no buffer space.
-     196                 :       virtual 
-     197               0 :       ~basic_streambuf() 
-     198               0 :       { }
-     199                 : 
-     200                 :       // [27.5.2.2.1] locales
-     201                 :       /**
-     202                 :        *  @brief  Entry point for imbue().
-     203                 :        *  @param  loc  The new locale.
-     204                 :        *  @return  The previous locale.
-     205                 :        *
-     206                 :        *  Calls the derived imbue(loc).
-     207                 :       */
-     208                 :       locale 
-     209                 :       pubimbue(const locale &__loc)
-     210                 :       {
-     211                 :         locale __tmp(this->getloc());
-     212                 :         this->imbue(__loc);
-     213                 :         _M_buf_locale = __loc;
-     214                 :         return __tmp;
-     215                 :       }
-     216                 : 
-     217                 :       /**
-     218                 :        *  @brief  Locale access.
-     219                 :        *  @return  The current locale in effect.
-     220                 :        *
-     221                 :        *  If pubimbue(loc) has been called, then the most recent @c loc
-     222                 :        *  is returned.  Otherwise the global locale in effect at the time
-     223                 :        *  of construction is returned.
-     224                 :       */
-     225                 :       locale   
-     226                 :       getloc() const
-     227                 :       { return _M_buf_locale; } 
-     228                 : 
-     229                 :       // [27.5.2.2.2] buffer management and positioning
-     230                 :       //@{
-     231                 :       /**
-     232                 :        *  @brief  Entry points for derived buffer functions.
-     233                 :        *
-     234                 :        *  The public versions of @c pubfoo dispatch to the protected
-     235                 :        *  derived @c foo member functions, passing the arguments (if any)
-     236                 :        *  and returning the result unchanged.
-     237                 :       */
-     238                 :       __streambuf_type* 
-     239                 :       pubsetbuf(char_type* __s, streamsize __n) 
-     240                 :       { return this->setbuf(__s, __n); }
-     241                 : 
-     242                 :       pos_type 
-     243                 :       pubseekoff(off_type __off, ios_base::seekdir __way, 
-     244                 :                  ios_base::openmode __mode = ios_base::in | ios_base::out)
-     245                 :       { return this->seekoff(__off, __way, __mode); }
-     246                 : 
-     247                 :       pos_type 
-     248                 :       pubseekpos(pos_type __sp,
-     249                 :                  ios_base::openmode __mode = ios_base::in | ios_base::out)
-     250                 :       { return this->seekpos(__sp, __mode); }
-     251                 : 
-     252                 :       int 
-     253                 :       pubsync() { return this->sync(); }
-     254                 :       //@}
-     255                 : 
-     256                 :       // [27.5.2.2.3] get area
-     257                 :       /**
-     258                 :        *  @brief  Looking ahead into the stream.
-     259                 :        *  @return  The number of characters available.
-     260                 :        *
-     261                 :        *  If a read position is available, returns the number of characters
-     262                 :        *  available for reading before the buffer must be refilled.
-     263                 :        *  Otherwise returns the derived @c showmanyc().
-     264                 :       */
-     265                 :       streamsize 
-     266                 :       in_avail() 
-     267                 :       { 
-     268                 :         const streamsize __ret = this->egptr() - this->gptr();
-     269                 :         return __ret ? __ret : this->showmanyc();
-     270                 :       }
-     271                 : 
-     272                 :       /**
-     273                 :        *  @brief  Getting the next character.
-     274                 :        *  @return  The next character, or eof.
-     275                 :        *
-     276                 :        *  Calls @c sbumpc(), and if that function returns
-     277                 :        *  @c traits::eof(), so does this function.  Otherwise, @c sgetc().
-     278                 :       */
-     279                 :       int_type 
-     280                 :       snextc()
-     281                 :       {
-     282                 :         int_type __ret = traits_type::eof();
-     283                 :         if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), 
-     284                 :                                                        __ret), true))
-     285                 :           __ret = this->sgetc();
-     286                 :         return __ret;
-     287                 :       }
-     288                 : 
-     289                 :       /**
-     290                 :        *  @brief  Getting the next character.
-     291                 :        *  @return  The next character, or eof.
-     292                 :        *
-     293                 :        *  If the input read position is available, returns that character
-     294                 :        *  and increments the read pointer, otherwise calls and returns
-     295                 :        *  @c uflow().
-     296                 :       */
-     297                 :       int_type 
-     298                 :       sbumpc()
-     299                 :       {
-     300                 :         int_type __ret;
-     301                 :         if (__builtin_expect(this->gptr() < this->egptr(), true))
-     302                 :           {
-     303                 :             __ret = traits_type::to_int_type(*this->gptr());
-     304                 :             this->gbump(1);
-     305                 :           }
-     306                 :         else 
-     307                 :           __ret = this->uflow();
-     308                 :         return __ret;
-     309                 :       }
-     310                 : 
-     311                 :       /**
-     312                 :        *  @brief  Getting the next character.
-     313                 :        *  @return  The next character, or eof.
-     314                 :        *
-     315                 :        *  If the input read position is available, returns that character,
-     316                 :        *  otherwise calls and returns @c underflow().  Does not move the 
-     317                 :        *  read position after fetching the character.
-     318                 :       */
-     319                 :       int_type 
-     320                 :       sgetc()
-     321                 :       {
-     322                 :         int_type __ret;
-     323                 :         if (__builtin_expect(this->gptr() < this->egptr(), true))
-     324                 :           __ret = traits_type::to_int_type(*this->gptr());
-     325                 :         else 
-     326                 :           __ret = this->underflow();
-     327                 :         return __ret;
-     328                 :       }
-     329                 : 
-     330                 :       /**
-     331                 :        *  @brief  Entry point for xsgetn.
-     332                 :        *  @param  s  A buffer area.
-     333                 :        *  @param  n  A count.
-     334                 :        *
-     335                 :        *  Returns xsgetn(s,n).  The effect is to fill @a s[0] through
-     336                 :        *  @a s[n-1] with characters from the input sequence, if possible.
-     337                 :       */
-     338                 :       streamsize 
-     339                 :       sgetn(char_type* __s, streamsize __n)
-     340                 :       { return this->xsgetn(__s, __n); }
-     341                 : 
-     342                 :       // [27.5.2.2.4] putback
-     343                 :       /**
-     344                 :        *  @brief  Pushing characters back into the input stream.
-     345                 :        *  @param  c  The character to push back.
-     346                 :        *  @return  The previous character, if possible.
-     347                 :        *
-     348                 :        *  Similar to sungetc(), but @a c is pushed onto the stream instead
-     349                 :        *  of "the previous character".  If successful, the next character
-     350                 :        *  fetched from the input stream will be @a c.
-     351                 :       */
-     352                 :       int_type 
-     353                 :       sputbackc(char_type __c)
-     354                 :       {
-     355                 :         int_type __ret;
-     356                 :         const bool __testpos = this->eback() < this->gptr();
-     357                 :         if (__builtin_expect(!__testpos || 
-     358                 :                              !traits_type::eq(__c, this->gptr()[-1]), false))
-     359                 :           __ret = this->pbackfail(traits_type::to_int_type(__c));
-     360                 :         else 
-     361                 :           {
-     362                 :             this->gbump(-1);
-     363                 :             __ret = traits_type::to_int_type(*this->gptr());
-     364                 :           }
-     365                 :         return __ret;
-     366                 :       }
-     367                 : 
-     368                 :       /**
-     369                 :        *  @brief  Moving backwards in the input stream.
-     370                 :        *  @return  The previous character, if possible.
-     371                 :        *
-     372                 :        *  If a putback position is available, this function decrements the
-     373                 :        *  input pointer and returns that character.  Otherwise, calls and
-     374                 :        *  returns pbackfail().  The effect is to "unget" the last character
-     375                 :        *  "gotten".
-     376                 :       */
-     377                 :       int_type 
-     378                 :       sungetc()
-     379                 :       {
-     380                 :         int_type __ret;
-     381                 :         if (__builtin_expect(this->eback() < this->gptr(), true))
-     382                 :           {
-     383                 :             this->gbump(-1);
-     384                 :             __ret = traits_type::to_int_type(*this->gptr());
-     385                 :           }
-     386                 :         else 
-     387                 :           __ret = this->pbackfail();
-     388                 :         return __ret;
-     389                 :       }
-     390                 : 
-     391                 :       // [27.5.2.2.5] put area
-     392                 :       /**
-     393                 :        *  @brief  Entry point for all single-character output functions.
-     394                 :        *  @param  c  A character to output.
-     395                 :        *  @return  @a c, if possible.
-     396                 :        *
-     397                 :        *  One of two public output functions.
-     398                 :        *
-     399                 :        *  If a write position is available for the output sequence (i.e.,
-     400                 :        *  the buffer is not full), stores @a c in that position, increments
-     401                 :        *  the position, and returns @c traits::to_int_type(c).  If a write
-     402                 :        *  position is not available, returns @c overflow(c).
-     403                 :       */
-     404                 :       int_type 
-     405                 :       sputc(char_type __c)
-     406                 :       {
-     407                 :         int_type __ret;
-     408                 :         if (__builtin_expect(this->pptr() < this->epptr(), true))
-     409                 :           {
-     410                 :             *this->pptr() = __c;
-     411                 :             this->pbump(1);
-     412                 :             __ret = traits_type::to_int_type(__c);
-     413                 :           }
-     414                 :         else
-     415                 :           __ret = this->overflow(traits_type::to_int_type(__c));
-     416                 :         return __ret;
-     417                 :       }
-     418                 : 
-     419                 :       /**
-     420                 :        *  @brief  Entry point for all single-character output functions.
-     421                 :        *  @param  s  A buffer read area.
-     422                 :        *  @param  n  A count.
-     423                 :        *
-     424                 :        *  One of two public output functions.
-     425                 :        *
-     426                 :        *
-     427                 :        *  Returns xsputn(s,n).  The effect is to write @a s[0] through
-     428                 :        *  @a s[n-1] to the output sequence, if possible.
-     429                 :       */
-     430                 :       streamsize 
-     431                 :       sputn(const char_type* __s, streamsize __n)
-     432                 :       { return this->xsputn(__s, __n); }
-     433                 : 
-     434                 :     protected:
-     435                 :       /**
-     436                 :        *  @brief  Base constructor.
-     437                 :        *
-     438                 :        *  Only called from derived constructors, and sets up all the
-     439                 :        *  buffer data to zero, including the pointers described in the
-     440                 :        *  basic_streambuf class description.  Note that, as a result,
-     441                 :        *  - the class starts with no read nor write positions available,
-     442                 :        *  - this is not an error
-     443                 :       */
-     444               0 :       basic_streambuf()
-     445                 :       : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), 
-     446                 :       _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
-     447               0 :       _M_buf_locale(locale()) 
-     448               0 :       { }
-     449                 : 
-     450                 :       // [27.5.2.3.1] get area access
-     451                 :       //@{
-     452                 :       /**
-     453                 :        *  @brief  Access to the get area.
-     454                 :        *
-     455                 :        *  These functions are only available to other protected functions,
-     456                 :        *  including derived classes.
-     457                 :        *
-     458                 :        *  - eback() returns the beginning pointer for the input sequence
-     459                 :        *  - gptr() returns the next pointer for the input sequence
-     460                 :        *  - egptr() returns the end pointer for the input sequence
-     461                 :       */
-     462                 :       char_type* 
-     463                 :       eback() const { return _M_in_beg; }
-     464                 : 
-     465                 :       char_type* 
-     466               0 :       gptr()  const { return _M_in_cur;  }
-     467                 : 
-     468                 :       char_type* 
-     469               0 :       egptr() const { return _M_in_end; }
-     470                 :       //@}
-     471                 : 
-     472                 :       /**
-     473                 :        *  @brief  Moving the read position.
-     474                 :        *  @param  n  The delta by which to move.
-     475                 :        *
-     476                 :        *  This just advances the read position without returning any data.
-     477                 :       */
-     478                 :       void 
-     479               0 :       gbump(int __n) { _M_in_cur += __n; }
-     480                 : 
-     481                 :       /**
-     482                 :        *  @brief  Setting the three read area pointers.
-     483                 :        *  @param  gbeg  A pointer.
-     484                 :        *  @param  gnext  A pointer.
-     485                 :        *  @param  gend  A pointer.
-     486                 :        *  @post  @a gbeg == @c eback(), @a gnext == @c gptr(), and
-     487                 :        *         @a gend == @c egptr()
-     488                 :       */
-     489                 :       void 
-     490                 :       setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
-     491                 :       {
-     492                 :         _M_in_beg = __gbeg;
-     493                 :         _M_in_cur = __gnext;
-     494                 :         _M_in_end = __gend;
-     495                 :       }
-     496                 : 
-     497                 :       // [27.5.2.3.2] put area access
-     498                 :       //@{
-     499                 :       /**
-     500                 :        *  @brief  Access to the put area.
-     501                 :        *
-     502                 :        *  These functions are only available to other protected functions,
-     503                 :        *  including derived classes.
-     504                 :        *
-     505                 :        *  - pbase() returns the beginning pointer for the output sequence
-     506                 :        *  - pptr() returns the next pointer for the output sequence
-     507                 :        *  - epptr() returns the end pointer for the output sequence
-     508                 :       */
-     509                 :       char_type* 
-     510               0 :       pbase() const { return _M_out_beg; }
-     511                 : 
-     512                 :       char_type* 
-     513               0 :       pptr() const { return _M_out_cur; }
-     514                 : 
-     515                 :       char_type* 
-     516                 :       epptr() const { return _M_out_end; }
-     517                 :       //@}
-     518                 : 
-     519                 :       /**
-     520                 :        *  @brief  Moving the write position.
-     521                 :        *  @param  n  The delta by which to move.
-     522                 :        *
-     523                 :        *  This just advances the write position without returning any data.
-     524                 :       */
-     525                 :       void 
-     526               0 :       pbump(int __n) { _M_out_cur += __n; }
-     527                 : 
-     528                 :       /**
-     529                 :        *  @brief  Setting the three write area pointers.
-     530                 :        *  @param  pbeg  A pointer.
-     531                 :        *  @param  pend  A pointer.
-     532                 :        *  @post  @a pbeg == @c pbase(), @a pbeg == @c pptr(), and
-     533                 :        *         @a pend == @c epptr()
-     534                 :       */
-     535                 :       void 
-     536               0 :       setp(char_type* __pbeg, char_type* __pend)
-     537                 :       { 
-     538               0 :         _M_out_beg = _M_out_cur = __pbeg; 
-     539               0 :         _M_out_end = __pend;
-     540               0 :       }
-     541                 : 
-     542                 :       // [27.5.2.4] virtual functions
-     543                 :       // [27.5.2.4.1] locales
-     544                 :       /**
-     545                 :        *  @brief  Changes translations.
-     546                 :        *  @param  loc  A new locale.
-     547                 :        *
-     548                 :        *  Translations done during I/O which depend on the current locale
-     549                 :        *  are changed by this call.  The standard adds, "Between invocations
-     550                 :        *  of this function a class derived from streambuf can safely cache
-     551                 :        *  results of calls to locale functions and to members of facets
-     552                 :        *  so obtained."
-     553                 :        *
-     554                 :        *  @note  Base class version does nothing.
-     555                 :       */
-     556                 :       virtual void 
-     557               0 :       imbue(const locale&) 
-     558               0 :       { }
-     559                 : 
-     560                 :       // [27.5.2.4.2] buffer management and positioning
-     561                 :       /**
-     562                 :        *  @brief  Manipulates the buffer.
-     563                 :        *
-     564                 :        *  Each derived class provides its own appropriate behavior.  See
-     565                 :        *  the next-to-last paragraph of 
-     566                 :        *  http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 for
-     567                 :        *  more on this function.
-     568                 :        *
-     569                 :        *  @note  Base class version does nothing, returns @c this.
-     570                 :       */
-     571                 :       virtual basic_streambuf<char_type,_Traits>* 
-     572               0 :       setbuf(char_type*, streamsize)
-     573               0 :       { return this; }
-     574                 :       
-     575                 :       /**
-     576                 :        *  @brief  Alters the stream positions.
-     577                 :        *
-     578                 :        *  Each derived class provides its own appropriate behavior.
-     579                 :        *  @note  Base class version does nothing, returns a @c pos_type
-     580                 :        *         that represents an invalid stream position.
-     581                 :       */
-     582                 :       virtual pos_type 
-     583                 :       seekoff(off_type, ios_base::seekdir,
-     584               0 :               ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
-     585               0 :       { return pos_type(off_type(-1)); } 
-     586                 : 
-     587                 :       /**
-     588                 :        *  @brief  Alters the stream positions.
-     589                 :        *
-     590                 :        *  Each derived class provides its own appropriate behavior.
-     591                 :        *  @note  Base class version does nothing, returns a @c pos_type
-     592                 :        *         that represents an invalid stream position.
-     593                 :       */
-     594                 :       virtual pos_type 
-     595                 :       seekpos(pos_type, 
-     596               0 :               ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
-     597               0 :       { return pos_type(off_type(-1)); } 
-     598                 : 
-     599                 :       /**
-     600                 :        *  @brief  Synchronizes the buffer arrays with the controlled sequences.
-     601                 :        *  @return  -1 on failure.
-     602                 :        *
-     603                 :        *  Each derived class provides its own appropriate behavior,
-     604                 :        *  including the definition of "failure".
-     605                 :        *  @note  Base class version does nothing, returns zero.
-     606                 :       */
-     607                 :       virtual int 
-     608               0 :       sync() { return 0; }
-     609                 : 
-     610                 :       // [27.5.2.4.3] get area
-     611                 :       /**
-     612                 :        *  @brief  Investigating the data available.
-     613                 :        *  @return  An estimate of the number of characters available in the
-     614                 :        *           input sequence, or -1.
-     615                 :        *
-     616                 :        *  "If it returns a positive value, then successive calls to
-     617                 :        *  @c underflow() will not return @c traits::eof() until at least that
-     618                 :        *  number of characters have been supplied.  If @c showmanyc()
-     619                 :        *  returns -1, then calls to @c underflow() or @c uflow() will fail."
-     620                 :        *  [27.5.2.4.3]/1
-     621                 :        *
-     622                 :        *  @note  Base class version does nothing, returns zero.
-     623                 :        *  @note  The standard adds that "the intention is not only that the
-     624                 :        *         calls [to underflow or uflow] will not return @c eof() but
-     625                 :        *         that they will return "immediately".
-     626                 :        *  @note  The standard adds that "the morphemes of @c showmanyc are
-     627                 :        *         "es-how-many-see", not "show-manic".
-     628                 :       */
-     629                 :       virtual streamsize 
-     630               0 :       showmanyc() { return 0; }
-     631                 : 
-     632                 :       /**
-     633                 :        *  @brief  Multiple character extraction.
-     634                 :        *  @param  s  A buffer area.
-     635                 :        *  @param  n  Maximum number of characters to assign.
-     636                 :        *  @return  The number of characters assigned.
-     637                 :        *
-     638                 :        *  Fills @a s[0] through @a s[n-1] with characters from the input
-     639                 :        *  sequence, as if by @c sbumpc().  Stops when either @a n characters
-     640                 :        *  have been copied, or when @c traits::eof() would be copied.
-     641                 :        *
-     642                 :        *  It is expected that derived classes provide a more efficient
-     643                 :        *  implementation by overriding this definition.
-     644                 :       */
-     645                 :       virtual streamsize 
-     646                 :       xsgetn(char_type* __s, streamsize __n);
-     647                 : 
-     648                 :       /**
-     649                 :        *  @brief  Fetches more data from the controlled sequence.
-     650                 :        *  @return  The first character from the <em>pending sequence</em>.
-     651                 :        *
-     652                 :        *  Informally, this function is called when the input buffer is
-     653                 :        *  exhausted (or does not exist, as buffering need not actually be
-     654                 :        *  done).  If a buffer exists, it is "refilled".  In either case, the
-     655                 :        *  next available character is returned, or @c traits::eof() to
-     656                 :        *  indicate a null pending sequence.
-     657                 :        *
-     658                 :        *  For a formal definition of the pending sequence, see a good text
-     659                 :        *  such as Langer & Kreft, or [27.5.2.4.3]/7-14.
-     660                 :        *
-     661                 :        *  A functioning input streambuf can be created by overriding only
-     662                 :        *  this function (no buffer area will be used).  For an example, see
-     663                 :        *  http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#6
-     664                 :        *
-     665                 :        *  @note  Base class version does nothing, returns eof().
-     666                 :       */
-     667                 :       virtual int_type 
-     668               0 :       underflow()
-     669               0 :       { return traits_type::eof(); }
-     670                 : 
-     671                 :       /**
-     672                 :        *  @brief  Fetches more data from the controlled sequence.
-     673                 :        *  @return  The first character from the <em>pending sequence</em>.
-     674                 :        *
-     675                 :        *  Informally, this function does the same thing as @c underflow(),
-     676                 :        *  and in fact is required to call that function.  It also returns
-     677                 :        *  the new character, like @c underflow() does.  However, this
-     678                 :        *  function also moves the read position forward by one.
-     679                 :       */
-     680                 :       virtual int_type 
-     681               0 :       uflow() 
-     682                 :       {
-     683               0 :         int_type __ret = traits_type::eof();
-     684                 :         const bool __testeof = traits_type::eq_int_type(this->underflow(), 
-     685               0 :                                                         __ret);
-     686               0 :         if (!__testeof)
-     687                 :           {
-     688               0 :             __ret = traits_type::to_int_type(*this->gptr());
-     689               0 :             this->gbump(1);
-     690                 :           }
-     691               0 :         return __ret;    
-     692                 :       }
-     693                 : 
-     694                 :       // [27.5.2.4.4] putback
-     695                 :       /**
-     696                 :        *  @brief  Tries to back up the input sequence.
-     697                 :        *  @param  c  The character to be inserted back into the sequence.
-     698                 :        *  @return  eof() on failure, "some other value" on success
-     699                 :        *  @post  The constraints of @c gptr(), @c eback(), and @c pptr()
-     700                 :        *         are the same as for @c underflow().
-     701                 :        *
-     702                 :        *  @note  Base class version does nothing, returns eof().
-     703                 :       */
-     704                 :       virtual int_type 
-     705               0 :       pbackfail(int_type /* __c */  = traits_type::eof())
-     706               0 :       { return traits_type::eof(); }
-     707                 : 
-     708                 :       // Put area:
-     709                 :       /**
-     710                 :        *  @brief  Multiple character insertion.
-     711                 :        *  @param  s  A buffer area.
-     712                 :        *  @param  n  Maximum number of characters to write.
-     713                 :        *  @return  The number of characters written.
-     714                 :        *
-     715                 :        *  Writes @a s[0] through @a s[n-1] to the output sequence, as if
-     716                 :        *  by @c sputc().  Stops when either @a n characters have been
-     717                 :        *  copied, or when @c sputc() would return @c traits::eof().
-     718                 :        *
-     719                 :        *  It is expected that derived classes provide a more efficient
-     720                 :        *  implementation by overriding this definition.
-     721                 :       */
-     722                 :       virtual streamsize 
-     723                 :       xsputn(const char_type* __s, streamsize __n);
-     724                 : 
-     725                 :       /**
-     726                 :        *  @brief  Consumes data from the buffer; writes to the
-     727                 :        *          controlled sequence.
-     728                 :        *  @param  c  An additional character to consume.
-     729                 :        *  @return  eof() to indicate failure, something else (usually
-     730                 :        *           @a c, or not_eof())
-     731                 :        *
-     732                 :        *  Informally, this function is called when the output buffer is full
-     733                 :        *  (or does not exist, as buffering need not actually be done).  If a
-     734                 :        *  buffer exists, it is "consumed", with "some effect" on the
-     735                 :        *  controlled sequence.  (Typically, the buffer is written out to the
-     736                 :        *  sequence verbatim.)  In either case, the character @a c is also
-     737                 :        *  written out, if @a c is not @c eof().
-     738                 :        *
-     739                 :        *  For a formal definition of this function, see a good text
-     740                 :        *  such as Langer & Kreft, or [27.5.2.4.5]/3-7.
-     741                 :        *
-     742                 :        *  A functioning output streambuf can be created by overriding only
-     743                 :        *  this function (no buffer area will be used).
-     744                 :        *
-     745                 :        *  @note  Base class version does nothing, returns eof().
-     746                 :       */
-     747                 :       virtual int_type 
-     748                 :       overflow(int_type /* __c */ = traits_type::eof())
-     749                 :       { return traits_type::eof(); }
-     750                 : 
-     751                 : #if _GLIBCXX_DEPRECATED
-     752                 :     // Annex D.6
-     753                 :     public:
-     754                 :       /**
-     755                 :        *  @brief  Tosses a character.
-     756                 :        *
-     757                 :        *  Advances the read pointer, ignoring the character that would have
-     758                 :        *  been read.
-     759                 :        *
-     760                 :        *  See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html
-     761                 :        */
-     762                 :       void 
-     763                 :       stossc() 
-     764                 :       {
-     765                 :         if (this->gptr() < this->egptr()) 
-     766                 :           this->gbump(1);
-     767                 :         else 
-     768                 :           this->uflow();
-     769                 :       }
-     770                 : #endif
-     771                 : 
-     772                 :     private:
-     773                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
-     774                 :       // Side effect of DR 50. 
-     775                 :       basic_streambuf(const __streambuf_type& __sb)
-     776                 :       : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur), 
-     777                 :       _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg), 
-     778                 :       _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
-     779                 :       _M_buf_locale(__sb._M_buf_locale) 
-     780                 :       { }
-     781                 : 
-     782                 :       __streambuf_type& 
-     783                 :       operator=(const __streambuf_type&) { return *this; };
-     784                 :     };
-     785                 : 
-     786                 :   // Explicit specialization declarations, defined in src/streambuf.cc.
-     787                 :   template<>
-     788                 :     streamsize
-     789                 :     __copy_streambufs_eof(basic_streambuf<char>* __sbin,
-     790                 :                           basic_streambuf<char>* __sbout, bool& __ineof);
-     791                 : #ifdef _GLIBCXX_USE_WCHAR_T
-     792                 :   template<>
-     793                 :     streamsize
-     794                 :     __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
-     795                 :                           basic_streambuf<wchar_t>* __sbout, bool& __ineof);
-     796                 : #endif
-     797                 : 
-     798                 : _GLIBCXX_END_NAMESPACE
-     799                 : 
-     800                 : #ifndef _GLIBCXX_EXPORT_TEMPLATE
-     801                 : # include <bits/streambuf.tcc>
-     802                 : #endif
-     803                 : 
-     804                 : #endif /* _GLIBCXX_STREAMBUF */
-
-
-
- - - - -
Generated by: LTP GCOV extension version 1.6
-
- - - -- cgit v1.2.3