Mercurial > hg-old > index.cgi
comparison lib/verify.h @ 421:3c2e1f24cc7d 3.0-beta2
Added generated files for release
author | lost@l-w.ca |
---|---|
date | Sun, 19 Sep 2010 01:33:24 -0600 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
420:7366deedfa85 | 421:3c2e1f24cc7d |
---|---|
1 /* Compile-time assert-like macros. | |
2 | |
3 Copyright (C) 2005-2006, 2009-2010 Free Software Foundation, Inc. | |
4 | |
5 This program is free software: you can redistribute it and/or modify | |
6 it under the terms of the GNU General Public License as published by | |
7 the Free Software Foundation; either version 3 of the License, or | |
8 (at your option) any later version. | |
9 | |
10 This program is distributed in the hope that it will be useful, | |
11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 GNU General Public License for more details. | |
14 | |
15 You should have received a copy of the GNU General Public License | |
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
17 | |
18 /* Written by Paul Eggert, Bruno Haible, and Jim Meyering. */ | |
19 | |
20 #ifndef VERIFY_H | |
21 # define VERIFY_H 1 | |
22 | |
23 /* Each of these macros verifies that its argument R is nonzero. To | |
24 be portable, R should be an integer constant expression. Unlike | |
25 assert (R), there is no run-time overhead. | |
26 | |
27 There are two macros, since no single macro can be used in all | |
28 contexts in C. verify_true (R) is for scalar contexts, including | |
29 integer constant expression contexts. verify (R) is for declaration | |
30 contexts, e.g., the top level. | |
31 | |
32 Symbols ending in "__" are private to this header. | |
33 | |
34 The code below uses several ideas. | |
35 | |
36 * The first step is ((R) ? 1 : -1). Given an expression R, of | |
37 integral or boolean or floating-point type, this yields an | |
38 expression of integral type, whose value is later verified to be | |
39 constant and nonnegative. | |
40 | |
41 * Next this expression W is wrapped in a type | |
42 struct verify_type__ { unsigned int verify_error_if_negative_size__: W; }. | |
43 If W is negative, this yields a compile-time error. No compiler can | |
44 deal with a bit-field of negative size. | |
45 | |
46 One might think that an array size check would have the same | |
47 effect, that is, that the type struct { unsigned int dummy[W]; } | |
48 would work as well. However, inside a function, some compilers | |
49 (such as C++ compilers and GNU C) allow local parameters and | |
50 variables inside array size expressions. With these compilers, | |
51 an array size check would not properly diagnose this misuse of | |
52 the verify macro: | |
53 | |
54 void function (int n) { verify (n < 0); } | |
55 | |
56 * For the verify macro, the struct verify_type__ will need to | |
57 somehow be embedded into a declaration. To be portable, this | |
58 declaration must declare an object, a constant, a function, or a | |
59 typedef name. If the declared entity uses the type directly, | |
60 such as in | |
61 | |
62 struct dummy {...}; | |
63 typedef struct {...} dummy; | |
64 extern struct {...} *dummy; | |
65 extern void dummy (struct {...} *); | |
66 extern struct {...} *dummy (void); | |
67 | |
68 two uses of the verify macro would yield colliding declarations | |
69 if the entity names are not disambiguated. A workaround is to | |
70 attach the current line number to the entity name: | |
71 | |
72 #define GL_CONCAT0(x, y) x##y | |
73 #define GL_CONCAT(x, y) GL_CONCAT0 (x, y) | |
74 extern struct {...} * GL_CONCAT(dummy,__LINE__); | |
75 | |
76 But this has the problem that two invocations of verify from | |
77 within the same macro would collide, since the __LINE__ value | |
78 would be the same for both invocations. | |
79 | |
80 A solution is to use the sizeof operator. It yields a number, | |
81 getting rid of the identity of the type. Declarations like | |
82 | |
83 extern int dummy [sizeof (struct {...})]; | |
84 extern void dummy (int [sizeof (struct {...})]); | |
85 extern int (*dummy (void)) [sizeof (struct {...})]; | |
86 | |
87 can be repeated. | |
88 | |
89 * Should the implementation use a named struct or an unnamed struct? | |
90 Which of the following alternatives can be used? | |
91 | |
92 extern int dummy [sizeof (struct {...})]; | |
93 extern int dummy [sizeof (struct verify_type__ {...})]; | |
94 extern void dummy (int [sizeof (struct {...})]); | |
95 extern void dummy (int [sizeof (struct verify_type__ {...})]); | |
96 extern int (*dummy (void)) [sizeof (struct {...})]; | |
97 extern int (*dummy (void)) [sizeof (struct verify_type__ {...})]; | |
98 | |
99 In the second and sixth case, the struct type is exported to the | |
100 outer scope; two such declarations therefore collide. GCC warns | |
101 about the first, third, and fourth cases. So the only remaining | |
102 possibility is the fifth case: | |
103 | |
104 extern int (*dummy (void)) [sizeof (struct {...})]; | |
105 | |
106 * This implementation exploits the fact that GCC does not warn about | |
107 the last declaration mentioned above. If a future version of GCC | |
108 introduces a warning for this, the problem could be worked around | |
109 by using code specialized to GCC, e.g.,: | |
110 | |
111 #if 4 <= __GNUC__ | |
112 # define verify(R) \ | |
113 extern int (* verify_function__ (void)) \ | |
114 [__builtin_constant_p (R) && (R) ? 1 : -1] | |
115 #endif | |
116 | |
117 * In C++, any struct definition inside sizeof is invalid. | |
118 Use a template type to work around the problem. */ | |
119 | |
120 | |
121 /* Verify requirement R at compile-time, as an integer constant expression. | |
122 Return 1. */ | |
123 | |
124 # ifdef __cplusplus | |
125 template <int w> | |
126 struct verify_type__ { unsigned int verify_error_if_negative_size__: w; }; | |
127 # define verify_true(R) \ | |
128 (!!sizeof (verify_type__<(R) ? 1 : -1>)) | |
129 # else | |
130 # define verify_true(R) \ | |
131 (!!sizeof \ | |
132 (struct { unsigned int verify_error_if_negative_size__: (R) ? 1 : -1; })) | |
133 # endif | |
134 | |
135 /* Verify requirement R at compile-time, as a declaration without a | |
136 trailing ';'. */ | |
137 | |
138 # define verify(R) extern int (* verify_function__ (void)) [verify_true (R)] | |
139 | |
140 #endif |