/src/FreeImage/Source/OpenEXR/IlmImf/ImfCheckedArithmetic.h

  1///////////////////////////////////////////////////////////////////////////
  2//
  3// Copyright (c) 2009, Industrial Light & Magic, a division of Lucas
  4// Digital Ltd. LLC
  5// 
  6// All rights reserved.
  7// 
  8// Redistribution and use in source and binary forms, with or without
  9// modification, are permitted provided that the following conditions are
 10// met:
 11// *       Redistributions of source code must retain the above copyright
 12// notice, this list of conditions and the following disclaimer.
 13// *       Redistributions in binary form must reproduce the above
 14// copyright notice, this list of conditions and the following disclaimer
 15// in the documentation and/or other materials provided with the
 16// distribution.
 17// *       Neither the name of Industrial Light & Magic nor the names of
 18// its contributors may be used to endorse or promote products derived
 19// from this software without specific prior written permission. 
 20// 
 21// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 22// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 23// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 24// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 25// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 26// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 27// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 28// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 29// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 30// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 31// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 32//
 33///////////////////////////////////////////////////////////////////////////
 34
 35#ifndef INCLUDED_IMF_CHECKED_ARITHMETIC_H
 36#define INCLUDED_IMF_CHECKED_ARITHMETIC_H
 37
 38//-----------------------------------------------------------------------------
 39//
 40//	Integer arithmetic operations that throw exceptions
 41//      on overflow, underflow or division by zero.
 42//
 43//-----------------------------------------------------------------------------
 44
 45#include <limits>
 46#include <IexMathExc.h>
 47
 48namespace Imf {
 49
 50template <bool b> struct StaticAssertionFailed;
 51template <> struct StaticAssertionFailed <true> {};
 52
 53#define IMF_STATIC_ASSERT(x) \
 54    do {StaticAssertionFailed <x> staticAssertionFailed;} while (false)
 55
 56
 57template <class T>
 58T
 59uiMult (T a, T b)
 60{
 61    //
 62    // Unsigned integer multiplication
 63    //
 64
 65    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
 66                        std::numeric_limits<T>::is_integer);
 67
 68    if (a > 0 && b > std::numeric_limits<T>::max() / a)
 69        throw Iex::OverflowExc ("Integer multiplication overflow.");
 70
 71    return a * b;
 72}
 73
 74
 75template <class T>
 76T
 77uiDiv (T a, T b)
 78{
 79    //
 80    // Unsigned integer division
 81    //
 82
 83    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
 84                        std::numeric_limits<T>::is_integer);
 85
 86    if (b == 0)
 87        throw Iex::DivzeroExc ("Integer division by zero.");
 88
 89    return a / b;
 90}
 91
 92
 93template <class T>
 94T
 95uiAdd (T a, T b)
 96{
 97    //
 98    // Unsigned integer addition
 99    //
100
101    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
102                        std::numeric_limits<T>::is_integer);
103
104    if (a > std::numeric_limits<T>::max() - b)
105        throw Iex::OverflowExc ("Integer addition overflow.");
106
107    return a + b;
108}
109
110
111template <class T>
112T
113uiSub (T a, T b)
114{
115    //
116    // Unsigned integer subtraction
117    //
118
119    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
120                        std::numeric_limits<T>::is_integer);
121
122    if (a < b)
123        throw Iex::UnderflowExc ("Integer subtraction underflow.");
124
125    return a - b;
126}
127
128
129template <class T>
130size_t
131checkArraySize (T n, size_t s)
132{
133    //
134    // Verify that the size, in bytes, of an array with n elements
135    // of size s can be computed without overflowing:
136    //
137    // If computing
138    //
139    //      size_t (n) * s
140    //
141    // would overflow, then throw an Iex::OverflowExc exception.
142    // Otherwise return
143    //
144    //      size_t (n).
145    //
146
147    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
148                        std::numeric_limits<T>::is_integer);
149
150    IMF_STATIC_ASSERT (sizeof (T) <= sizeof (size_t));
151
152    if (size_t (n) > std::numeric_limits<size_t>::max() / s)
153        throw Iex::OverflowExc ("Integer multiplication overflow.");
154
155    return size_t (n);
156}
157
158
159} // namespace Imf
160
161#endif