LCOV - lcov.info - /usr/include/c++/4.3/new

LTP GCOV extension - code coverage report
Current view: | directory - usr/include/c++/4.3 - new
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 2
Code covered: | 50.0 % |  | Executed lines: | 1

           1                 : // The -*- C++ -*- dynamic memory management header.
           2                 :
           3                 : // Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
           4                 : // 2003, 2004, 2005, 2006, 2007
           5                 : // Free Software Foundation
           6                 :
           7                 : // This file is part of GCC.
           8                 : //
           9                 : // GCC is free software; you can redistribute it and/or modify
          10                 : // it under the terms of the GNU General Public License as published by
          11                 : // the Free Software Foundation; either version 2, or (at your option)
          12                 : // any later version.
          13                 : //
          14                 : // GCC is distributed in the hope that it will be useful,
          15                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
          16                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
          17                 : // GNU General Public License for more details.
          18                 : //
          19                 : // You should have received a copy of the GNU General Public License
          20                 : // along with GCC; see the file COPYING.  If not, write to
          21                 : // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
          22                 : // Boston, MA 02110-1301, USA.
          23                 :
          24                 : // As a special exception, you may use this file as part of a free software
          25                 : // library without restriction.  Specifically, if other files instantiate
          26                 : // templates or use macros or inline functions from this file, or you compile
          27                 : // this file and link it with other files to produce an executable, this
          28                 : // file does not by itself cause the resulting executable to be covered by
          29                 : // the GNU General Public License.  This exception does not however
          30                 : // invalidate any other reasons why the executable file might be covered by
          31                 : // the GNU General Public License.
          32                 :
          33                 : /** @file new
          34                 :  *  This is a Standard C++ Library header.
          35                 :  *
          36                 :  *  The header @c new defines several functions to manage dynamic memory and
          37                 :  *  handling memory allocation errors; see
          38                 :  *  http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#4 for more.
          39                 :  */
          40                 :
          41                 : #ifndef _NEW
          42                 : #define _NEW
          43                 :
          44                 : #include <cstddef>
          45                 : #include <exception>
          46                 :
          47                 : #pragma GCC visibility push(default)
          48                 :
          49                 : extern "C++" {
          50                 :
          51                 : namespace std
          52                 : {
          53                 :   /**
          54                 :    *  @brief  Exception possibly thrown by @c new.
          55                 :    *
          56                 :    *  @c bad_alloc (or classes derived from it) is used to report allocation
          57                 :    *  errors from the throwing forms of @c new.  */
          58                 :   class bad_alloc : public exception
          59                 :   {
          60                 :   public:
          61                 :     bad_alloc() throw() { }
          62                 :
          63                 :     // This declaration is not useless:
          64                 :     // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
          65                 :     virtual ~bad_alloc() throw();
          66                 :
          67                 :     // See comment in eh_exception.cc.
          68                 :     virtual const char* what() const throw();
          69                 :   };
          70                 :
          71                 :   struct nothrow_t { };
          72                 :
          73                 :   extern const nothrow_t nothrow;
          74                 :
          75                 :   /** If you write your own error handler to be called by @c new, it must
          76                 :    *  be of this type.  */
          77                 :   typedef void (*new_handler)();
          78                 :
          79                 :   /// Takes a replacement handler as the argument, returns the
          80                 :   /// previous handler.
          81                 :   new_handler set_new_handler(new_handler) throw();
          82                 : } // namespace std
          83                 :
          84                 : //@{
          85                 : /** These are replaceable signatures:
          86                 :  *  - normal single new and delete (no arguments, throw @c bad_alloc on error)
          87                 :  *  - normal array new and delete (same)
          88                 :  *  - @c nothrow single new and delete (take a @c nothrow argument, return
          89                 :  *    @c NULL on error)
          90                 :  *  - @c nothrow array new and delete (same)
          91                 :  *
          92                 :  *  Placement new and delete signatures (take a memory address argument,
          93                 :  *  does nothing) may not be replaced by a user's program.
          94                 : */
          95                 : void* operator new(std::size_t) throw (std::bad_alloc);
          96                 : void* operator new[](std::size_t) throw (std::bad_alloc);
          97                 : void operator delete(void*) throw();
          98                 : void operator delete[](void*) throw();
          99                 : void* operator new(std::size_t, const std::nothrow_t&) throw();
         100                 : void* operator new[](std::size_t, const std::nothrow_t&) throw();
         101                 : void operator delete(void*, const std::nothrow_t&) throw();
         102                 : void operator delete[](void*, const std::nothrow_t&) throw();
         103                 :
         104                 : // Default placement versions of operator new.
         105         5858225 : inline void* operator new(std::size_t, void* __p) throw() { return __p; }
         106                 : inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
         107                 :
         108                 : // Default placement versions of operator delete.
         109               0 : inline void  operator delete  (void*, void*) throw() { }
         110                 : inline void  operator delete[](void*, void*) throw() { }
         111                 : //@}
         112                 : } // extern "C++"
         113                 :
         114                 : #pragma GCC visibility pop
         115                 :
         116                 : #endif

Generated by: LTP GCOV extension version 1.6