Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. // The -*- C++ -*- dynamic memory management header.
  2.  
  3. // Copyright (C) 1994-2013 Free Software Foundation, Inc.
  4.  
  5. // This file is part of GCC.
  6. //
  7. // GCC is free software; you can redistribute it and/or modify
  8. // it under the terms of the GNU General Public License as published by
  9. // the Free Software Foundation; either version 3, or (at your option)
  10. // any later version.
  11. //
  12. // GCC 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. // Under Section 7 of GPL version 3, you are granted additional
  18. // permissions described in the GCC Runtime Library Exception, version
  19. // 3.1, as published by the Free Software Foundation.
  20.  
  21. // You should have received a copy of the GNU General Public License and
  22. // a copy of the GCC Runtime Library Exception along with this program;
  23. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24. // <http://www.gnu.org/licenses/>.
  25.  
  26. /** @file new
  27.  *  This is a Standard C++ Library header.
  28.  *
  29.  *  The header @c new defines several functions to manage dynamic memory and
  30.  *  handling memory allocation errors; see
  31.  *  http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#4 for more.
  32.  */
  33.  
  34. #ifndef _NEW
  35. #define _NEW
  36.  
  37. #pragma GCC system_header
  38.  
  39. #include <bits/c++config.h>
  40. #include <exception>
  41.  
  42. #pragma GCC visibility push(default)
  43.  
  44. extern "C++" {
  45.  
  46. namespace std
  47. {
  48.   /**
  49.    *  @brief  Exception possibly thrown by @c new.
  50.    *  @ingroup exceptions
  51.    *
  52.    *  @c bad_alloc (or classes derived from it) is used to report allocation
  53.    *  errors from the throwing forms of @c new.  */
  54.   class bad_alloc : public exception
  55.   {
  56.   public:
  57.     bad_alloc() throw() { }
  58.  
  59.     // This declaration is not useless:
  60.     // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
  61.     virtual ~bad_alloc() throw();
  62.  
  63.     // See comment in eh_exception.cc.
  64.     virtual const char* what() const throw();
  65.   };
  66.  
  67.   struct nothrow_t { };
  68.  
  69.   extern const nothrow_t nothrow;
  70.  
  71.   /** If you write your own error handler to be called by @c new, it must
  72.    *  be of this type.  */
  73.   typedef void (*new_handler)();
  74.  
  75.   /// Takes a replacement handler as the argument, returns the
  76.   /// previous handler.
  77.   new_handler set_new_handler(new_handler) throw();
  78. } // namespace std
  79.  
  80. //@{
  81. /** These are replaceable signatures:
  82.  *  - normal single new and delete (no arguments, throw @c bad_alloc on error)
  83.  *  - normal array new and delete (same)
  84.  *  - @c nothrow single new and delete (take a @c nothrow argument, return
  85.  *    @c NULL on error)
  86.  *  - @c nothrow array new and delete (same)
  87.  *
  88.  *  Placement new and delete signatures (take a memory address argument,
  89.  *  does nothing) may not be replaced by a user's program.
  90. */
  91. void* operator new(std::size_t) _GLIBCXX_THROW (std::bad_alloc)
  92.   __attribute__((__externally_visible__));
  93. void* operator new[](std::size_t) _GLIBCXX_THROW (std::bad_alloc)
  94.   __attribute__((__externally_visible__));
  95. void operator delete(void*) _GLIBCXX_USE_NOEXCEPT
  96.   __attribute__((__externally_visible__));
  97. void operator delete[](void*) _GLIBCXX_USE_NOEXCEPT
  98.   __attribute__((__externally_visible__));
  99. void* operator new(std::size_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
  100.   __attribute__((__externally_visible__));
  101. void* operator new[](std::size_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
  102.   __attribute__((__externally_visible__));
  103. void operator delete(void*, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
  104.   __attribute__((__externally_visible__));
  105. void operator delete[](void*, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT
  106.   __attribute__((__externally_visible__));
  107.  
  108. // Default placement versions of operator new.
  109. inline void* operator new(std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
  110. { return __p; }
  111. inline void* operator new[](std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
  112. { return __p; }
  113.  
  114. // Default placement versions of operator delete.
  115. inline void operator delete  (void*, void*) _GLIBCXX_USE_NOEXCEPT { }
  116. inline void operator delete[](void*, void*) _GLIBCXX_USE_NOEXCEPT { }
  117. //@}
  118. } // extern "C++"
  119.  
  120. #pragma GCC visibility pop
  121.  
  122. #endif
  123.