Import Chromium base/numerics to resolve integer overflow.
[pdfium.git] / third_party / macros.h
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // This file contains macros and macro-like constructs (e.g., templates) that
6 // are commonly used throughout Chromium source. (It may also contain things
7 // that are closely related to things that are commonly used that belong in this
8 // file.)
9
10 #ifndef BASE_MACROS_H_
11 #define BASE_MACROS_H_
12
13 // The COMPILE_ASSERT macro can be used to verify that a compile time
14 // expression is true. For example, you could use it to verify the
15 // size of a static array:
16 //
17 //   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES,
18 //                  content_type_names_incorrect_size);
19 //
20 // or to make sure a struct is smaller than a certain size:
21 //
22 //   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
23 //
24 // The second argument to the macro is the name of the variable. If
25 // the expression is false, most compilers will issue a warning/error
26 // containing the name of the variable.
27
28 #undef COMPILE_ASSERT
29
30 #if __cplusplus >= 201103L
31
32 // Under C++11, just use static_assert.
33 #define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
34
35 #else
36
37 template <bool>
38 struct CompileAssert {
39 };
40
41 #define COMPILE_ASSERT(expr, msg) \
42   typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] ALLOW_UNUSED
43
44 // Implementation details of COMPILE_ASSERT:
45 //
46 // - COMPILE_ASSERT works by defining an array type that has -1
47 //   elements (and thus is invalid) when the expression is false.
48 //
49 // - The simpler definition
50 //
51 //     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
52 //
53 //   does not work, as gcc supports variable-length arrays whose sizes
54 //   are determined at run-time (this is gcc's extension and not part
55 //   of the C++ standard).  As a result, gcc fails to reject the
56 //   following code with the simple definition:
57 //
58 //     int foo;
59 //     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
60 //                               // not a compile-time constant.
61 //
62 // - By using the type CompileAssert<(bool(expr))>, we ensures that
63 //   expr is a compile-time constant.  (Template arguments must be
64 //   determined at compile-time.)
65 //
66 // - The outer parentheses in CompileAssert<(bool(expr))> are necessary
67 //   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
68 //
69 //     CompileAssert<bool(expr)>
70 //
71 //   instead, these compilers will refuse to compile
72 //
73 //     COMPILE_ASSERT(5 > 0, some_message);
74 //
75 //   (They seem to think the ">" in "5 > 0" marks the end of the
76 //   template argument list.)
77 //
78 // - The array size is (bool(expr) ? 1 : -1), instead of simply
79 //
80 //     ((expr) ? 1 : -1).
81 //
82 //   This is to avoid running into a bug in MS VC 7.1, which
83 //   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
84
85 #endif
86
87 #endif  // BASE_MACROS_H_