Part 1 of 2: <http://webkit.org/b/56337> Enable -Werror on ANGLE
[WebKit-https.git] / Source / ThirdParty / ANGLE / src / compiler / ConstantUnion.h
1 //
2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 #ifndef _CONSTANT_UNION_INCLUDED_
8 #define _CONSTANT_UNION_INCLUDED_
9
10 #include <assert.h>
11
12 class ConstantUnion {
13 public:
14
15     POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)        
16     void setIConst(int i) {iConst = i; type = EbtInt; }
17     void setFConst(float f) {fConst = f; type = EbtFloat; }
18     void setBConst(bool b) {bConst = b; type = EbtBool; }
19
20     int getIConst() { return iConst; }
21     float getFConst() { return fConst; }
22     bool getBConst() { return bConst; }
23     int getIConst() const { return iConst; }
24     float getFConst() const { return fConst; }
25     bool getBConst() const { return bConst; }
26
27     bool operator==(const int i) const
28     {
29         if (i == iConst)
30             return true;
31
32         return false;
33     }
34
35     bool operator==(const float f) const
36     {
37         if (f == fConst)
38             return true;
39
40         return false;
41     }
42
43     bool operator==(const bool b) const
44     {
45         if (b == bConst)
46             return true;
47
48         return false;
49     }
50
51     bool operator==(const ConstantUnion& constant) const
52     {
53         if (constant.type != type)
54             return false;
55
56         switch (type) {
57         case EbtInt:
58             if (constant.iConst == iConst)
59                 return true;
60
61             break;
62         case EbtFloat:
63             if (constant.fConst == fConst)
64                 return true;
65
66             break;
67         case EbtBool:
68             if (constant.bConst == bConst)
69                 return true;
70
71             break;
72         default:
73             return false;
74         }
75
76         return false;
77     }
78
79     bool operator!=(const int i) const
80     {
81         return !operator==(i);
82     }
83
84     bool operator!=(const float f) const
85     {
86         return !operator==(f);
87     }
88
89     bool operator!=(const bool b) const
90     {
91         return !operator==(b);
92     }
93
94     bool operator!=(const ConstantUnion& constant) const
95     {
96         return !operator==(constant);
97     }
98
99     bool operator>(const ConstantUnion& constant) const
100     { 
101         assert(type == constant.type);
102         switch (type) {
103         case EbtInt:
104             if (iConst > constant.iConst)
105                 return true;
106
107             return false;
108         case EbtFloat:
109             if (fConst > constant.fConst)
110                 return true;
111
112             return false;
113         default:
114             assert(false && "Default missing");
115             return false;
116         }
117
118         return false;
119     }
120
121     bool operator<(const ConstantUnion& constant) const
122     { 
123         assert(type == constant.type);
124         switch (type) {
125         case EbtInt:
126             if (iConst < constant.iConst)
127                 return true;
128
129             return false;
130         case EbtFloat:
131             if (fConst < constant.fConst)
132                 return true;
133
134             return false;
135         default:
136             assert(false && "Default missing");
137             return false;
138         }
139
140         return false;
141     }
142
143     ConstantUnion operator+(const ConstantUnion& constant) const
144     { 
145         ConstantUnion returnValue;
146         assert(type == constant.type);
147         switch (type) {
148         case EbtInt: returnValue.setIConst(iConst + constant.iConst); break;
149         case EbtFloat: returnValue.setFConst(fConst + constant.fConst); break;
150         default: assert(false && "Default missing");
151         }
152
153         return returnValue;
154     }
155
156     ConstantUnion operator-(const ConstantUnion& constant) const
157     { 
158         ConstantUnion returnValue;
159         assert(type == constant.type);
160         switch (type) {
161         case EbtInt: returnValue.setIConst(iConst - constant.iConst); break;
162         case EbtFloat: returnValue.setFConst(fConst - constant.fConst); break;
163         default: assert(false && "Default missing");
164         }
165
166         return returnValue;
167     }
168
169     ConstantUnion operator*(const ConstantUnion& constant) const
170     { 
171         ConstantUnion returnValue;
172         assert(type == constant.type);
173         switch (type) {
174         case EbtInt: returnValue.setIConst(iConst * constant.iConst); break;
175         case EbtFloat: returnValue.setFConst(fConst * constant.fConst); break; 
176         default: assert(false && "Default missing");
177         }
178
179         return returnValue;
180     }
181
182     ConstantUnion operator%(const ConstantUnion& constant) const
183     { 
184         ConstantUnion returnValue;
185         assert(type == constant.type);
186         switch (type) {
187         case EbtInt: returnValue.setIConst(iConst % constant.iConst); break;
188         default:     assert(false && "Default missing");
189         }
190
191         return returnValue;
192     }
193
194     ConstantUnion operator>>(const ConstantUnion& constant) const
195     { 
196         ConstantUnion returnValue;
197         assert(type == constant.type);
198         switch (type) {
199         case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break;
200         default:     assert(false && "Default missing");
201         }
202
203         return returnValue;
204     }
205
206     ConstantUnion operator<<(const ConstantUnion& constant) const
207     { 
208         ConstantUnion returnValue;
209         assert(type == constant.type);
210         switch (type) {
211         case EbtInt: returnValue.setIConst(iConst << constant.iConst); break;
212         default:     assert(false && "Default missing");
213         }
214
215         return returnValue;
216     }
217
218     ConstantUnion operator&(const ConstantUnion& constant) const
219     { 
220         ConstantUnion returnValue;
221         assert(type == constant.type);
222         switch (type) {
223         case EbtInt:  returnValue.setIConst(iConst & constant.iConst); break;
224         default:     assert(false && "Default missing");
225         }
226
227         return returnValue;
228     }
229
230     ConstantUnion operator|(const ConstantUnion& constant) const
231     { 
232         ConstantUnion returnValue;
233         assert(type == constant.type);
234         switch (type) {
235         case EbtInt:  returnValue.setIConst(iConst | constant.iConst); break;
236         default:     assert(false && "Default missing");
237         }
238
239         return returnValue;
240     }
241
242     ConstantUnion operator^(const ConstantUnion& constant) const
243     { 
244         ConstantUnion returnValue;
245         assert(type == constant.type);
246         switch (type) {
247         case EbtInt:  returnValue.setIConst(iConst ^ constant.iConst); break;
248         default:     assert(false && "Default missing");
249         }
250
251         return returnValue;
252     }
253
254     ConstantUnion operator&&(const ConstantUnion& constant) const
255     { 
256         ConstantUnion returnValue;
257         assert(type == constant.type);
258         switch (type) {
259         case EbtBool: returnValue.setBConst(bConst && constant.bConst); break;
260         default:     assert(false && "Default missing");
261         }
262
263         return returnValue;
264     }
265
266     ConstantUnion operator||(const ConstantUnion& constant) const
267     { 
268         ConstantUnion returnValue;
269         assert(type == constant.type);
270         switch (type) {
271         case EbtBool: returnValue.setBConst(bConst || constant.bConst); break;
272         default:     assert(false && "Default missing");
273         }
274
275         return returnValue;
276     }
277
278     TBasicType getType() const { return type; }
279 private:
280
281     union  {
282         int iConst;  // used for ivec, scalar ints
283         bool bConst; // used for bvec, scalar bools
284         float fConst;   // used for vec, mat, scalar floats
285     } ;
286
287     TBasicType type;
288 };
289
290 #endif // _CONSTANT_UNION_INCLUDED_