alloc_func.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ALLOC_FUNC_HPP
#define ALLOC_FUNC_HPP
 
/*
 * Functions to exit badly with an error message.
 * It has to be linked so the error messages are not
 * duplicated in each object file making the final
 * binary needlessly large.
 */
 
[[noreturn]] void MallocError(size_t size);
[[noreturn]] void ReallocError(size_t size);
 
inline void CheckAllocationConstraints(size_t element_size, size_t num_elements)
{
  if (num_elements > SIZE_MAX / element_size) MallocError(SIZE_MAX);
}
 
template <typename T>
inline void CheckAllocationConstraints(size_t num_elements)
{
  CheckAllocationConstraints(sizeof(T), num_elements);
}
 
template <typename T>
inline T *MallocT(size_t num_elements)
{
  /*
   * MorphOS cannot handle 0 elements allocations, or rather that always
   * returns nullptr. So we do that for *all* allocations, thus causing it
   * to behave the same on all OSes.
   */
  if (num_elements == 0) return nullptr;
 
  /* Ensure the size does not overflow. */
  CheckAllocationConstraints<T>(num_elements);
 
  T *t_ptr = (T*)malloc(num_elements * sizeof(T));
  if (t_ptr == nullptr) MallocError(num_elements * sizeof(T));
  return t_ptr;
}
 
template <typename T>
inline T *CallocT(size_t num_elements)
{
  /*
   * MorphOS cannot handle 0 elements allocations, or rather that always
   * returns nullptr. So we do that for *all* allocations, thus causing it
   * to behave the same on all OSes.
   */
  if (num_elements == 0) return nullptr;
 
  T *t_ptr = (T*)calloc(num_elements, sizeof(T));
  if (t_ptr == nullptr) MallocError(num_elements * sizeof(T));
  return t_ptr;
}
 
template <typename T>
inline T *ReallocT(T *t_ptr, size_t num_elements)
{
  /*
   * MorphOS cannot handle 0 elements allocations, or rather that always
   * returns nullptr. So we do that for *all* allocations, thus causing it
   * to behave the same on all OSes.
   */
  if (num_elements == 0) {
    free(t_ptr);
    return nullptr;
  }
 
  /* Ensure the size does not overflow. */
  CheckAllocationConstraints<T>(num_elements);
 
  t_ptr = (T*)realloc(static_cast<void *>(t_ptr), num_elements * sizeof(T));
  if (t_ptr == nullptr) ReallocError(num_elements * sizeof(T));
  return t_ptr;
}
 
#endif /* ALLOC_FUNC_HPP */