cf531ea40582363a5300ddcceee3ee701dd93d23
[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         }
73
74         return false;
75     }
76
77     bool operator!=(const int i) const
78     {
79         return !operator==(i);
80     }
81
82     bool operator!=(const float f) const
83     {
84         return !operator==(f);
85     }
86
87     bool operator!=(const bool b) const
88     {
89         return !operator==(b);
90     }
91
92     bool operator!=(const ConstantUnion& constant) const
93     {
94         return !operator==(constant);
95     }
96
97     bool operator>(const ConstantUnion& constant) const
98     { 
99         assert(type == constant.type);
100         switch (type) {
101         case EbtInt:
102             if (iConst > constant.iConst)
103                 return true;
104
105             return false;
106         case EbtFloat:
107             if (fConst > constant.fConst)
108                 return true;
109
110             return false;
111         default:
112             assert(false && "Default missing");
113             return false;
114         }
115
116         return false;
117     }
118
119     bool operator<(const ConstantUnion& constant) const
120     { 
121         assert(type == constant.type);
122         switch (type) {
123         case EbtInt:
124             if (iConst < constant.iConst)
125                 return true;
126
127             return false;
128         case EbtFloat:
129             if (fConst < constant.fConst)
130                 return true;
131
132             return false;
133         default:
134             assert(false && "Default missing");
135             return false;
136         }
137
138         return false;
139     }
140
141     ConstantUnion operator+(const ConstantUnion& constant) const
142     { 
143         ConstantUnion returnValue;
144         assert(type == constant.type);
145         switch (type) {
146         case EbtInt: returnValue.setIConst(iConst + constant.iConst); break;
147         case EbtFloat: returnValue.setFConst(fConst + constant.fConst); break;
148         default: assert(false && "Default missing");
149         }
150
151         return returnValue;
152     }
153
154     ConstantUnion operator-(const ConstantUnion& constant) const
155     { 
156         ConstantUnion returnValue;
157         assert(type == constant.type);
158         switch (type) {
159         case EbtInt: returnValue.setIConst(iConst - constant.iConst); break;
160         case EbtFloat: returnValue.setFConst(fConst - constant.fConst); break;
161         default: assert(false && "Default missing");
162         }
163
164         return returnValue;
165     }
166
167     ConstantUnion operator*(const ConstantUnion& constant) const
168     { 
169         ConstantUnion returnValue;
170         assert(type == constant.type);
171         switch (type) {
172         case EbtInt: returnValue.setIConst(iConst * constant.iConst); break;
173         case EbtFloat: returnValue.setFConst(fConst * constant.fConst); break; 
174         default: assert(false && "Default missing");
175         }
176
177         return returnValue;
178     }
179
180     ConstantUnion operator%(const ConstantUnion& constant) const
181     { 
182         ConstantUnion returnValue;
183         assert(type == constant.type);
184         switch (type) {
185         case EbtInt: returnValue.setIConst(iConst % constant.iConst); break;
186         default:     assert(false && "Default missing");
187         }
188
189         return returnValue;
190     }
191
192     ConstantUnion operator>>(const ConstantUnion& constant) const
193     { 
194         ConstantUnion returnValue;
195         assert(type == constant.type);
196         switch (type) {
197         case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break;
198         default:     assert(false && "Default missing");
199         }
200
201         return returnValue;
202     }
203
204     ConstantUnion operator<<(const ConstantUnion& constant) const
205     { 
206         ConstantUnion returnValue;
207         assert(type == constant.type);
208         switch (type) {
209         case EbtInt: returnValue.setIConst(iConst << constant.iConst); break;
210         default:     assert(false && "Default missing");
211         }
212
213         return returnValue;
214     }
215
216     ConstantUnion operator&(const ConstantUnion& constant) const
217     { 
218         ConstantUnion returnValue;
219         assert(type == constant.type);
220         switch (type) {
221         case EbtInt:  returnValue.setIConst(iConst & constant.iConst); break;
222         default:     assert(false && "Default missing");
223         }
224
225         return returnValue;
226     }
227
228     ConstantUnion operator|(const ConstantUnion& constant) const
229     { 
230         ConstantUnion returnValue;
231         assert(type == constant.type);
232         switch (type) {
233         case EbtInt:  returnValue.setIConst(iConst | constant.iConst); break;
234         default:     assert(false && "Default missing");
235         }
236
237         return returnValue;
238     }
239
240     ConstantUnion operator^(const ConstantUnion& constant) const
241     { 
242         ConstantUnion returnValue;
243         assert(type == constant.type);
244         switch (type) {
245         case EbtInt:  returnValue.setIConst(iConst ^ constant.iConst); break;
246         default:     assert(false && "Default missing");
247         }
248
249         return returnValue;
250     }
251
252     ConstantUnion operator&&(const ConstantUnion& constant) const
253     { 
254         ConstantUnion returnValue;
255         assert(type == constant.type);
256         switch (type) {
257         case EbtBool: returnValue.setBConst(bConst && constant.bConst); break;
258         default:     assert(false && "Default missing");
259         }
260
261         return returnValue;
262     }
263
264     ConstantUnion operator||(const ConstantUnion& constant) const
265     { 
266         ConstantUnion returnValue;
267         assert(type == constant.type);
268         switch (type) {
269         case EbtBool: returnValue.setBConst(bConst || constant.bConst); break;
270         default:     assert(false && "Default missing");
271         }
272
273         return returnValue;
274     }
275
276     TBasicType getType() const { return type; }
277 private:
278
279     union  {
280         int iConst;  // used for ivec, scalar ints
281         bool bConst; // used for bvec, scalar bools
282         float fConst;   // used for vec, mat, scalar floats
283     } ;
284
285     TBasicType type;
286 };
287
288 #endif // _CONSTANT_UNION_INCLUDED_