1 // 2 // Copyright (C) 2002-2005 3Dlabs Inc. Ltd. 3 // Copyright (C) 2013 LunarG, Inc. 4 // Copyright (C) 2017 ARM Limited. 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 10 // are met: 11 // 12 // Redistributions of source code must retain the above copyright 13 // notice, this list of conditions and the following disclaimer. 14 // 15 // Redistributions in binary form must reproduce the above 16 // copyright notice, this list of conditions and the following 17 // disclaimer in the documentation and/or other materials provided 18 // with the distribution. 19 // 20 // Neither the name of 3Dlabs Inc. Ltd. nor the names of its 21 // contributors may be used to endorse or promote products derived 22 // from this software without specific prior written permission. 23 // 24 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 25 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 26 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 27 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 28 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 29 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 30 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 31 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 32 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 34 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 // POSSIBILITY OF SUCH DAMAGE. 36 // 37 38 #ifndef _CONSTANT_UNION_INCLUDED_ 39 #define _CONSTANT_UNION_INCLUDED_ 40 41 #include "../Include/Common.h" 42 #include "../Include/BaseTypes.h" 43 44 namespace glslang { 45 46 class TConstUnion { 47 public: POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator ())48 POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) 49 50 TConstUnion() : iConst(0), type(EbtInt) { } 51 setI8Const(signed char i)52 void setI8Const(signed char i) 53 { 54 i8Const = i; 55 type = EbtInt8; 56 } 57 setU8Const(unsigned char u)58 void setU8Const(unsigned char u) 59 { 60 u8Const = u; 61 type = EbtUint8; 62 } 63 setI16Const(signed short i)64 void setI16Const(signed short i) 65 { 66 i16Const = i; 67 type = EbtInt16; 68 } 69 setU16Const(unsigned short u)70 void setU16Const(unsigned short u) 71 { 72 u16Const = u; 73 type = EbtUint16; 74 } 75 setIConst(int i)76 void setIConst(int i) 77 { 78 iConst = i; 79 type = EbtInt; 80 } 81 setUConst(unsigned int u)82 void setUConst(unsigned int u) 83 { 84 uConst = u; 85 type = EbtUint; 86 } 87 setI64Const(long long i64)88 void setI64Const(long long i64) 89 { 90 i64Const = i64; 91 type = EbtInt64; 92 } 93 setU64Const(unsigned long long u64)94 void setU64Const(unsigned long long u64) 95 { 96 u64Const = u64; 97 type = EbtUint64; 98 } 99 setDConst(double d)100 void setDConst(double d) 101 { 102 dConst = d; 103 type = EbtDouble; 104 } 105 setBConst(bool b)106 void setBConst(bool b) 107 { 108 bConst = b; 109 type = EbtBool; 110 } 111 setSConst(const TString * s)112 void setSConst(const TString* s) 113 { 114 sConst = s; 115 type = EbtString; 116 } 117 getI8Const()118 signed char getI8Const() const { return i8Const; } getU8Const()119 unsigned char getU8Const() const { return u8Const; } getI16Const()120 signed short getI16Const() const { return i16Const; } getU16Const()121 unsigned short getU16Const() const { return u16Const; } getIConst()122 int getIConst() const { return iConst; } getUConst()123 unsigned int getUConst() const { return uConst; } getI64Const()124 long long getI64Const() const { return i64Const; } getU64Const()125 unsigned long long getU64Const() const { return u64Const; } getDConst()126 double getDConst() const { return dConst; } getBConst()127 bool getBConst() const { return bConst; } getSConst()128 const TString* getSConst() const { return sConst; } 129 130 bool operator==(const signed char i) const 131 { 132 if (i == i8Const) 133 return true; 134 135 return false; 136 } 137 138 bool operator==(const unsigned char u) const 139 { 140 if (u == u8Const) 141 return true; 142 143 return false; 144 } 145 146 bool operator==(const signed short i) const 147 { 148 if (i == i16Const) 149 return true; 150 151 return false; 152 } 153 154 bool operator==(const unsigned short u) const 155 { 156 if (u == u16Const) 157 return true; 158 159 return false; 160 } 161 162 bool operator==(const int i) const 163 { 164 if (i == iConst) 165 return true; 166 167 return false; 168 } 169 170 bool operator==(const unsigned int u) const 171 { 172 if (u == uConst) 173 return true; 174 175 return false; 176 } 177 178 bool operator==(const long long i64) const 179 { 180 if (i64 == i64Const) 181 return true; 182 183 return false; 184 } 185 186 bool operator==(const unsigned long long u64) const 187 { 188 if (u64 == u64Const) 189 return true; 190 191 return false; 192 } 193 194 bool operator==(const double d) const 195 { 196 if (d == dConst) 197 return true; 198 199 return false; 200 } 201 202 bool operator==(const bool b) const 203 { 204 if (b == bConst) 205 return true; 206 207 return false; 208 } 209 210 bool operator==(const TConstUnion& constant) const 211 { 212 if (constant.type != type) 213 return false; 214 215 switch (type) { 216 case EbtInt16: 217 if (constant.i16Const == i16Const) 218 return true; 219 220 break; 221 case EbtUint16: 222 if (constant.u16Const == u16Const) 223 return true; 224 225 break; 226 case EbtInt8: 227 if (constant.i8Const == i8Const) 228 return true; 229 230 break; 231 case EbtUint8: 232 if (constant.u8Const == u8Const) 233 return true; 234 235 break; 236 case EbtInt: 237 if (constant.iConst == iConst) 238 return true; 239 240 break; 241 case EbtUint: 242 if (constant.uConst == uConst) 243 return true; 244 245 break; 246 case EbtInt64: 247 if (constant.i64Const == i64Const) 248 return true; 249 250 break; 251 case EbtUint64: 252 if (constant.u64Const == u64Const) 253 return true; 254 255 break; 256 case EbtDouble: 257 if (constant.dConst == dConst) 258 return true; 259 260 break; 261 case EbtBool: 262 if (constant.bConst == bConst) 263 return true; 264 265 break; 266 default: 267 assert(false && "Default missing"); 268 } 269 270 return false; 271 } 272 273 bool operator!=(const signed char i) const 274 { 275 return !operator==(i); 276 } 277 278 bool operator!=(const unsigned char u) const 279 { 280 return !operator==(u); 281 } 282 283 bool operator!=(const signed short i) const 284 { 285 return !operator==(i); 286 } 287 288 bool operator!=(const unsigned short u) const 289 { 290 return !operator==(u); 291 } 292 293 bool operator!=(const int i) const 294 { 295 return !operator==(i); 296 } 297 298 bool operator!=(const unsigned int u) const 299 { 300 return !operator==(u); 301 } 302 303 bool operator!=(const long long i) const 304 { 305 return !operator==(i); 306 } 307 308 bool operator!=(const unsigned long long u) const 309 { 310 return !operator==(u); 311 } 312 313 bool operator!=(const float f) const 314 { 315 return !operator==(f); 316 } 317 318 bool operator!=(const bool b) const 319 { 320 return !operator==(b); 321 } 322 323 bool operator!=(const TConstUnion& constant) const 324 { 325 return !operator==(constant); 326 } 327 328 bool operator>(const TConstUnion& constant) const 329 { 330 assert(type == constant.type); 331 switch (type) { 332 case EbtInt8: 333 if (i8Const > constant.i8Const) 334 return true; 335 336 return false; 337 case EbtUint8: 338 if (u8Const > constant.u8Const) 339 return true; 340 341 return false; 342 case EbtInt16: 343 if (i16Const > constant.i16Const) 344 return true; 345 346 return false; 347 case EbtUint16: 348 if (u16Const > constant.u16Const) 349 return true; 350 351 return false; 352 case EbtInt: 353 if (iConst > constant.iConst) 354 return true; 355 356 return false; 357 case EbtUint: 358 if (uConst > constant.uConst) 359 return true; 360 361 return false; 362 case EbtInt64: 363 if (i64Const > constant.i64Const) 364 return true; 365 366 return false; 367 case EbtUint64: 368 if (u64Const > constant.u64Const) 369 return true; 370 371 return false; 372 case EbtDouble: 373 if (dConst > constant.dConst) 374 return true; 375 376 return false; 377 default: 378 assert(false && "Default missing"); 379 return false; 380 } 381 } 382 383 bool operator<(const TConstUnion& constant) const 384 { 385 assert(type == constant.type); 386 switch (type) { 387 case EbtInt8: 388 if (i8Const < constant.i8Const) 389 return true; 390 391 return false; 392 case EbtUint8: 393 if (u8Const < constant.u8Const) 394 return true; 395 396 return false; 397 case EbtInt16: 398 if (i16Const < constant.i16Const) 399 return true; 400 401 return false; 402 case EbtUint16: 403 if (u16Const < constant.u16Const) 404 return true; 405 406 return false; 407 case EbtInt: 408 if (iConst < constant.iConst) 409 return true; 410 411 return false; 412 case EbtUint: 413 if (uConst < constant.uConst) 414 return true; 415 416 return false; 417 case EbtInt64: 418 if (i64Const < constant.i64Const) 419 return true; 420 421 return false; 422 case EbtUint64: 423 if (u64Const < constant.u64Const) 424 return true; 425 426 return false; 427 case EbtDouble: 428 if (dConst < constant.dConst) 429 return true; 430 431 return false; 432 default: 433 assert(false && "Default missing"); 434 return false; 435 } 436 } 437 438 TConstUnion operator+(const TConstUnion& constant) const 439 { 440 TConstUnion returnValue; 441 assert(type == constant.type); 442 switch (type) { 443 case EbtInt8: returnValue.setI8Const(i8Const + constant.i8Const); break; 444 case EbtInt16: returnValue.setI16Const(i16Const + constant.i16Const); break; 445 case EbtInt: returnValue.setIConst(iConst + constant.iConst); break; 446 case EbtInt64: returnValue.setI64Const(i64Const + constant.i64Const); break; 447 case EbtUint8: returnValue.setU8Const(u8Const + constant.u8Const); break; 448 case EbtUint16: returnValue.setU16Const(u16Const + constant.u16Const); break; 449 case EbtUint: returnValue.setUConst(uConst + constant.uConst); break; 450 case EbtUint64: returnValue.setU64Const(u64Const + constant.u64Const); break; 451 case EbtDouble: returnValue.setDConst(dConst + constant.dConst); break; 452 default: assert(false && "Default missing"); 453 } 454 455 return returnValue; 456 } 457 458 TConstUnion operator-(const TConstUnion& constant) const 459 { 460 TConstUnion returnValue; 461 assert(type == constant.type); 462 switch (type) { 463 case EbtInt8: returnValue.setI8Const(i8Const - constant.i8Const); break; 464 case EbtInt16: returnValue.setI16Const(i16Const - constant.i16Const); break; 465 case EbtInt: returnValue.setIConst(iConst - constant.iConst); break; 466 case EbtInt64: returnValue.setI64Const(i64Const - constant.i64Const); break; 467 case EbtUint8: returnValue.setU8Const(u8Const - constant.u8Const); break; 468 case EbtUint16: returnValue.setU16Const(u16Const - constant.u16Const); break; 469 case EbtUint: returnValue.setUConst(uConst - constant.uConst); break; 470 case EbtUint64: returnValue.setU64Const(u64Const - constant.u64Const); break; 471 case EbtDouble: returnValue.setDConst(dConst - constant.dConst); break; 472 default: assert(false && "Default missing"); 473 } 474 475 return returnValue; 476 } 477 478 TConstUnion operator*(const TConstUnion& constant) const 479 { 480 TConstUnion returnValue; 481 assert(type == constant.type); 482 switch (type) { 483 case EbtInt8: returnValue.setI8Const(i8Const * constant.i8Const); break; 484 case EbtInt16: returnValue.setI16Const(i16Const * constant.i16Const); break; 485 case EbtInt: returnValue.setIConst(iConst * constant.iConst); break; 486 case EbtInt64: returnValue.setI64Const(i64Const * constant.i64Const); break; 487 case EbtUint8: returnValue.setU8Const(u8Const * constant.u8Const); break; 488 case EbtUint16: returnValue.setU16Const(u16Const * constant.u16Const); break; 489 case EbtUint: returnValue.setUConst(uConst * constant.uConst); break; 490 case EbtUint64: returnValue.setU64Const(u64Const * constant.u64Const); break; 491 case EbtDouble: returnValue.setDConst(dConst * constant.dConst); break; 492 default: assert(false && "Default missing"); 493 } 494 495 return returnValue; 496 } 497 498 TConstUnion operator%(const TConstUnion& constant) const 499 { 500 TConstUnion returnValue; 501 assert(type == constant.type); 502 switch (type) { 503 case EbtInt8: returnValue.setI8Const(i8Const % constant.i8Const); break; 504 case EbtInt16: returnValue.setI8Const(i8Const % constant.i16Const); break; 505 case EbtInt: returnValue.setIConst(iConst % constant.iConst); break; 506 case EbtInt64: returnValue.setI64Const(i64Const % constant.i64Const); break; 507 case EbtUint8: returnValue.setU8Const(u8Const % constant.u8Const); break; 508 case EbtUint16: returnValue.setU16Const(u16Const % constant.u16Const); break; 509 case EbtUint: returnValue.setUConst(uConst % constant.uConst); break; 510 case EbtUint64: returnValue.setU64Const(u64Const % constant.u64Const); break; 511 default: assert(false && "Default missing"); 512 } 513 514 return returnValue; 515 } 516 517 TConstUnion operator>>(const TConstUnion& constant) const 518 { 519 TConstUnion returnValue; 520 switch (type) { 521 case EbtInt8: 522 switch (constant.type) { 523 case EbtInt8: returnValue.setI8Const(i8Const >> constant.i8Const); break; 524 case EbtUint8: returnValue.setI8Const(i8Const >> constant.u8Const); break; 525 case EbtInt16: returnValue.setI8Const(i8Const >> constant.i16Const); break; 526 case EbtUint16: returnValue.setI8Const(i8Const >> constant.u16Const); break; 527 case EbtInt: returnValue.setI8Const(i8Const >> constant.iConst); break; 528 case EbtUint: returnValue.setI8Const(i8Const >> constant.uConst); break; 529 case EbtInt64: returnValue.setI8Const(i8Const >> constant.i64Const); break; 530 case EbtUint64: returnValue.setI8Const(i8Const >> constant.u64Const); break; 531 default: assert(false && "Default missing"); 532 } 533 break; 534 case EbtUint8: 535 switch (constant.type) { 536 case EbtInt8: returnValue.setU8Const(u8Const >> constant.i8Const); break; 537 case EbtUint8: returnValue.setU8Const(u8Const >> constant.u8Const); break; 538 case EbtInt16: returnValue.setU8Const(u8Const >> constant.i16Const); break; 539 case EbtUint16: returnValue.setU8Const(u8Const >> constant.u16Const); break; 540 case EbtInt: returnValue.setU8Const(u8Const >> constant.iConst); break; 541 case EbtUint: returnValue.setU8Const(u8Const >> constant.uConst); break; 542 case EbtInt64: returnValue.setU8Const(u8Const >> constant.i64Const); break; 543 case EbtUint64: returnValue.setU8Const(u8Const >> constant.u64Const); break; 544 default: assert(false && "Default missing"); 545 } 546 break; 547 case EbtInt16: 548 switch (constant.type) { 549 case EbtInt8: returnValue.setI16Const(i16Const >> constant.i8Const); break; 550 case EbtUint8: returnValue.setI16Const(i16Const >> constant.u8Const); break; 551 case EbtInt16: returnValue.setI16Const(i16Const >> constant.i16Const); break; 552 case EbtUint16: returnValue.setI16Const(i16Const >> constant.u16Const); break; 553 case EbtInt: returnValue.setI16Const(i16Const >> constant.iConst); break; 554 case EbtUint: returnValue.setI16Const(i16Const >> constant.uConst); break; 555 case EbtInt64: returnValue.setI16Const(i16Const >> constant.i64Const); break; 556 case EbtUint64: returnValue.setI16Const(i16Const >> constant.u64Const); break; 557 default: assert(false && "Default missing"); 558 } 559 break; 560 case EbtUint16: 561 switch (constant.type) { 562 case EbtInt8: returnValue.setU16Const(u16Const >> constant.i8Const); break; 563 case EbtUint8: returnValue.setU16Const(u16Const >> constant.u8Const); break; 564 case EbtInt16: returnValue.setU16Const(u16Const >> constant.i16Const); break; 565 case EbtUint16: returnValue.setU16Const(u16Const >> constant.u16Const); break; 566 case EbtInt: returnValue.setU16Const(u16Const >> constant.iConst); break; 567 case EbtUint: returnValue.setU16Const(u16Const >> constant.uConst); break; 568 case EbtInt64: returnValue.setU16Const(u16Const >> constant.i64Const); break; 569 case EbtUint64: returnValue.setU16Const(u16Const >> constant.u64Const); break; 570 default: assert(false && "Default missing"); 571 } 572 break; 573 case EbtInt: 574 switch (constant.type) { 575 case EbtInt8: returnValue.setIConst(iConst >> constant.i8Const); break; 576 case EbtUint8: returnValue.setIConst(iConst >> constant.u8Const); break; 577 case EbtInt16: returnValue.setIConst(iConst >> constant.i16Const); break; 578 case EbtUint16: returnValue.setIConst(iConst >> constant.u16Const); break; 579 case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break; 580 case EbtUint: returnValue.setIConst(iConst >> constant.uConst); break; 581 case EbtInt64: returnValue.setIConst(iConst >> constant.i64Const); break; 582 case EbtUint64: returnValue.setIConst(iConst >> constant.u64Const); break; 583 default: assert(false && "Default missing"); 584 } 585 break; 586 case EbtUint: 587 switch (constant.type) { 588 case EbtInt8: returnValue.setUConst(uConst >> constant.i8Const); break; 589 case EbtUint8: returnValue.setUConst(uConst >> constant.u8Const); break; 590 case EbtInt16: returnValue.setUConst(uConst >> constant.i16Const); break; 591 case EbtUint16: returnValue.setUConst(uConst >> constant.u16Const); break; 592 case EbtInt: returnValue.setUConst(uConst >> constant.iConst); break; 593 case EbtUint: returnValue.setUConst(uConst >> constant.uConst); break; 594 case EbtInt64: returnValue.setUConst(uConst >> constant.i64Const); break; 595 case EbtUint64: returnValue.setUConst(uConst >> constant.u64Const); break; 596 default: assert(false && "Default missing"); 597 } 598 break; 599 case EbtInt64: 600 switch (constant.type) { 601 case EbtInt8: returnValue.setI64Const(i64Const >> constant.i8Const); break; 602 case EbtUint8: returnValue.setI64Const(i64Const >> constant.u8Const); break; 603 case EbtInt16: returnValue.setI64Const(i64Const >> constant.i16Const); break; 604 case EbtUint16: returnValue.setI64Const(i64Const >> constant.u16Const); break; 605 case EbtInt: returnValue.setI64Const(i64Const >> constant.iConst); break; 606 case EbtUint: returnValue.setI64Const(i64Const >> constant.uConst); break; 607 case EbtInt64: returnValue.setI64Const(i64Const >> constant.i64Const); break; 608 case EbtUint64: returnValue.setI64Const(i64Const >> constant.u64Const); break; 609 default: assert(false && "Default missing"); 610 } 611 break; 612 case EbtUint64: 613 switch (constant.type) { 614 case EbtInt8: returnValue.setU64Const(u64Const >> constant.i8Const); break; 615 case EbtUint8: returnValue.setU64Const(u64Const >> constant.u8Const); break; 616 case EbtInt16: returnValue.setU64Const(u64Const >> constant.i16Const); break; 617 case EbtUint16: returnValue.setU64Const(u64Const >> constant.u16Const); break; 618 case EbtInt: returnValue.setU64Const(u64Const >> constant.iConst); break; 619 case EbtUint: returnValue.setU64Const(u64Const >> constant.uConst); break; 620 case EbtInt64: returnValue.setU64Const(u64Const >> constant.i64Const); break; 621 case EbtUint64: returnValue.setU64Const(u64Const >> constant.u64Const); break; 622 default: assert(false && "Default missing"); 623 } 624 break; 625 default: assert(false && "Default missing"); 626 } 627 628 return returnValue; 629 } 630 631 TConstUnion operator<<(const TConstUnion& constant) const 632 { 633 TConstUnion returnValue; 634 switch (type) { 635 case EbtInt8: 636 switch (constant.type) { 637 case EbtInt8: returnValue.setI8Const(i8Const << constant.i8Const); break; 638 case EbtUint8: returnValue.setI8Const(i8Const << constant.u8Const); break; 639 case EbtInt16: returnValue.setI8Const(i8Const << constant.i16Const); break; 640 case EbtUint16: returnValue.setI8Const(i8Const << constant.u16Const); break; 641 case EbtInt: returnValue.setI8Const(i8Const << constant.iConst); break; 642 case EbtUint: returnValue.setI8Const(i8Const << constant.uConst); break; 643 case EbtInt64: returnValue.setI8Const(i8Const << constant.i64Const); break; 644 case EbtUint64: returnValue.setI8Const(i8Const << constant.u64Const); break; 645 default: assert(false && "Default missing"); 646 } 647 break; 648 case EbtUint8: 649 switch (constant.type) { 650 case EbtInt8: returnValue.setU8Const(u8Const << constant.i8Const); break; 651 case EbtUint8: returnValue.setU8Const(u8Const << constant.u8Const); break; 652 case EbtInt16: returnValue.setU8Const(u8Const << constant.i16Const); break; 653 case EbtUint16: returnValue.setU8Const(u8Const << constant.u16Const); break; 654 case EbtInt: returnValue.setU8Const(u8Const << constant.iConst); break; 655 case EbtUint: returnValue.setU8Const(u8Const << constant.uConst); break; 656 case EbtInt64: returnValue.setU8Const(u8Const << constant.i64Const); break; 657 case EbtUint64: returnValue.setU8Const(u8Const << constant.u64Const); break; 658 default: assert(false && "Default missing"); 659 } 660 break; 661 case EbtInt16: 662 switch (constant.type) { 663 case EbtInt8: returnValue.setI16Const(i16Const << constant.i8Const); break; 664 case EbtUint8: returnValue.setI16Const(i16Const << constant.u8Const); break; 665 case EbtInt16: returnValue.setI16Const(i16Const << constant.i16Const); break; 666 case EbtUint16: returnValue.setI16Const(i16Const << constant.u16Const); break; 667 case EbtInt: returnValue.setI16Const(i16Const << constant.iConst); break; 668 case EbtUint: returnValue.setI16Const(i16Const << constant.uConst); break; 669 case EbtInt64: returnValue.setI16Const(i16Const << constant.i64Const); break; 670 case EbtUint64: returnValue.setI16Const(i16Const << constant.u64Const); break; 671 default: assert(false && "Default missing"); 672 } 673 break; 674 case EbtUint16: 675 switch (constant.type) { 676 case EbtInt8: returnValue.setU16Const(u16Const << constant.i8Const); break; 677 case EbtUint8: returnValue.setU16Const(u16Const << constant.u8Const); break; 678 case EbtInt16: returnValue.setU16Const(u16Const << constant.i16Const); break; 679 case EbtUint16: returnValue.setU16Const(u16Const << constant.u16Const); break; 680 case EbtInt: returnValue.setU16Const(u16Const << constant.iConst); break; 681 case EbtUint: returnValue.setU16Const(u16Const << constant.uConst); break; 682 case EbtInt64: returnValue.setU16Const(u16Const << constant.i64Const); break; 683 case EbtUint64: returnValue.setU16Const(u16Const << constant.u64Const); break; 684 default: assert(false && "Default missing"); 685 } 686 break; 687 case EbtInt: 688 switch (constant.type) { 689 case EbtInt8: returnValue.setIConst(iConst << constant.i8Const); break; 690 case EbtUint8: returnValue.setIConst(iConst << constant.u8Const); break; 691 case EbtInt16: returnValue.setIConst(iConst << constant.i16Const); break; 692 case EbtUint16: returnValue.setIConst(iConst << constant.u16Const); break; 693 case EbtInt: returnValue.setIConst(iConst << constant.iConst); break; 694 case EbtUint: returnValue.setIConst(iConst << constant.uConst); break; 695 case EbtInt64: returnValue.setIConst(iConst << constant.i64Const); break; 696 case EbtUint64: returnValue.setIConst(iConst << constant.u64Const); break; 697 default: assert(false && "Default missing"); 698 } 699 break; 700 case EbtUint: 701 switch (constant.type) { 702 case EbtInt8: returnValue.setUConst(uConst << constant.i8Const); break; 703 case EbtUint8: returnValue.setUConst(uConst << constant.u8Const); break; 704 case EbtInt16: returnValue.setUConst(uConst << constant.i16Const); break; 705 case EbtUint16: returnValue.setUConst(uConst << constant.u16Const); break; 706 case EbtInt: returnValue.setUConst(uConst << constant.iConst); break; 707 case EbtUint: returnValue.setUConst(uConst << constant.uConst); break; 708 case EbtInt64: returnValue.setUConst(uConst << constant.i64Const); break; 709 case EbtUint64: returnValue.setUConst(uConst << constant.u64Const); break; 710 default: assert(false && "Default missing"); 711 } 712 break; 713 case EbtInt64: 714 switch (constant.type) { 715 case EbtInt8: returnValue.setI64Const(i64Const << constant.i8Const); break; 716 case EbtUint8: returnValue.setI64Const(i64Const << constant.u8Const); break; 717 case EbtInt16: returnValue.setI64Const(i64Const << constant.i16Const); break; 718 case EbtUint16: returnValue.setI64Const(i64Const << constant.u16Const); break; 719 case EbtInt: returnValue.setI64Const(i64Const << constant.iConst); break; 720 case EbtUint: returnValue.setI64Const(i64Const << constant.uConst); break; 721 case EbtInt64: returnValue.setI64Const(i64Const << constant.i64Const); break; 722 case EbtUint64: returnValue.setI64Const(i64Const << constant.u64Const); break; 723 default: assert(false && "Default missing"); 724 } 725 break; 726 case EbtUint64: 727 switch (constant.type) { 728 case EbtInt8: returnValue.setU64Const(u64Const << constant.i8Const); break; 729 case EbtUint8: returnValue.setU64Const(u64Const << constant.u8Const); break; 730 case EbtInt16: returnValue.setU64Const(u64Const << constant.i16Const); break; 731 case EbtUint16: returnValue.setU64Const(u64Const << constant.u16Const); break; 732 case EbtInt: returnValue.setU64Const(u64Const << constant.iConst); break; 733 case EbtUint: returnValue.setU64Const(u64Const << constant.uConst); break; 734 case EbtInt64: returnValue.setU64Const(u64Const << constant.i64Const); break; 735 case EbtUint64: returnValue.setU64Const(u64Const << constant.u64Const); break; 736 default: assert(false && "Default missing"); 737 } 738 break; 739 default: assert(false && "Default missing"); 740 } 741 742 return returnValue; 743 } 744 745 TConstUnion operator&(const TConstUnion& constant) const 746 { 747 TConstUnion returnValue; 748 assert(type == constant.type); 749 switch (type) { 750 case EbtInt8: returnValue.setI8Const(i8Const & constant.i8Const); break; 751 case EbtUint8: returnValue.setU8Const(u8Const & constant.u8Const); break; 752 case EbtInt16: returnValue.setI16Const(i16Const & constant.i16Const); break; 753 case EbtUint16: returnValue.setU16Const(u16Const & constant.u16Const); break; 754 case EbtInt: returnValue.setIConst(iConst & constant.iConst); break; 755 case EbtUint: returnValue.setUConst(uConst & constant.uConst); break; 756 case EbtInt64: returnValue.setI64Const(i64Const & constant.i64Const); break; 757 case EbtUint64: returnValue.setU64Const(u64Const & constant.u64Const); break; 758 default: assert(false && "Default missing"); 759 } 760 761 return returnValue; 762 } 763 764 TConstUnion operator|(const TConstUnion& constant) const 765 { 766 TConstUnion returnValue; 767 assert(type == constant.type); 768 switch (type) { 769 case EbtInt8: returnValue.setI8Const(i8Const | constant.i8Const); break; 770 case EbtUint8: returnValue.setU8Const(u8Const | constant.u8Const); break; 771 case EbtInt16: returnValue.setI16Const(i16Const | constant.i16Const); break; 772 case EbtUint16: returnValue.setU16Const(u16Const | constant.u16Const); break; 773 case EbtInt: returnValue.setIConst(iConst | constant.iConst); break; 774 case EbtUint: returnValue.setUConst(uConst | constant.uConst); break; 775 case EbtInt64: returnValue.setI64Const(i64Const | constant.i64Const); break; 776 case EbtUint64: returnValue.setU64Const(u64Const | constant.u64Const); break; 777 default: assert(false && "Default missing"); 778 } 779 780 return returnValue; 781 } 782 783 TConstUnion operator^(const TConstUnion& constant) const 784 { 785 TConstUnion returnValue; 786 assert(type == constant.type); 787 switch (type) { 788 case EbtInt8: returnValue.setI8Const(i8Const ^ constant.i8Const); break; 789 case EbtUint8: returnValue.setU8Const(u8Const ^ constant.u8Const); break; 790 case EbtInt16: returnValue.setI16Const(i16Const ^ constant.i16Const); break; 791 case EbtUint16: returnValue.setU16Const(u16Const ^ constant.u16Const); break; 792 case EbtInt: returnValue.setIConst(iConst ^ constant.iConst); break; 793 case EbtUint: returnValue.setUConst(uConst ^ constant.uConst); break; 794 case EbtInt64: returnValue.setI64Const(i64Const ^ constant.i64Const); break; 795 case EbtUint64: returnValue.setU64Const(u64Const ^ constant.u64Const); break; 796 default: assert(false && "Default missing"); 797 } 798 799 return returnValue; 800 } 801 802 TConstUnion operator~() const 803 { 804 TConstUnion returnValue; 805 switch (type) { 806 case EbtInt8: returnValue.setI8Const(~i8Const); break; 807 case EbtUint8: returnValue.setU8Const(~u8Const); break; 808 case EbtInt16: returnValue.setI16Const(~i16Const); break; 809 case EbtUint16: returnValue.setU16Const(~u16Const); break; 810 case EbtInt: returnValue.setIConst(~iConst); break; 811 case EbtUint: returnValue.setUConst(~uConst); break; 812 case EbtInt64: returnValue.setI64Const(~i64Const); break; 813 case EbtUint64: returnValue.setU64Const(~u64Const); break; 814 default: assert(false && "Default missing"); 815 } 816 817 return returnValue; 818 } 819 820 TConstUnion operator&&(const TConstUnion& constant) const 821 { 822 TConstUnion returnValue; 823 assert(type == constant.type); 824 switch (type) { 825 case EbtBool: returnValue.setBConst(bConst && constant.bConst); break; 826 default: assert(false && "Default missing"); 827 } 828 829 return returnValue; 830 } 831 832 TConstUnion operator||(const TConstUnion& constant) const 833 { 834 TConstUnion returnValue; 835 assert(type == constant.type); 836 switch (type) { 837 case EbtBool: returnValue.setBConst(bConst || constant.bConst); break; 838 default: assert(false && "Default missing"); 839 } 840 841 return returnValue; 842 } 843 getType()844 TBasicType getType() const { return type; } 845 846 private: 847 union { 848 signed char i8Const; // used for i8vec, scalar int8s 849 unsigned char u8Const; // used for u8vec, scalar uint8s 850 signed short i16Const; // used for i16vec, scalar int16s 851 unsigned short u16Const; // used for u16vec, scalar uint16s 852 int iConst; // used for ivec, scalar ints 853 unsigned int uConst; // used for uvec, scalar uints 854 long long i64Const; // used for i64vec, scalar int64s 855 unsigned long long u64Const; // used for u64vec, scalar uint64s 856 bool bConst; // used for bvec, scalar bools 857 double dConst; // used for vec, dvec, mat, dmat, scalar floats and doubles 858 const TString* sConst; // string constant 859 }; 860 861 TBasicType type; 862 }; 863 864 // Encapsulate having a pointer to an array of TConstUnion, 865 // which only needs to be allocated if its size is going to be 866 // bigger than 0. 867 // 868 // One convenience is being able to use [] to go inside the array, instead 869 // of C++ assuming it as an array of pointers to vectors. 870 // 871 // General usage is that the size is known up front, and it is 872 // created once with the proper size. 873 // 874 class TConstUnionArray { 875 public: POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator ())876 POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator()) 877 878 TConstUnionArray() : unionArray(nullptr) { } ~TConstUnionArray()879 virtual ~TConstUnionArray() { } 880 TConstUnionArray(int size)881 explicit TConstUnionArray(int size) 882 { 883 if (size == 0) 884 unionArray = nullptr; 885 else 886 unionArray = new TConstUnionVector(size); 887 } TConstUnionArray(const TConstUnionArray & a)888 TConstUnionArray(const TConstUnionArray& a) : unionArray(a.unionArray) { } TConstUnionArray(const TConstUnionArray & a,int start,int size)889 TConstUnionArray(const TConstUnionArray& a, int start, int size) 890 { 891 unionArray = new TConstUnionVector(size); 892 for (int i = 0; i < size; ++i) 893 (*unionArray)[i] = a[start + i]; 894 } 895 896 // Use this constructor for a smear operation TConstUnionArray(int size,const TConstUnion & val)897 TConstUnionArray(int size, const TConstUnion& val) 898 { 899 unionArray = new TConstUnionVector(size, val); 900 } 901 size()902 int size() const { return unionArray ? (int)unionArray->size() : 0; } 903 TConstUnion& operator[](size_t index) { return (*unionArray)[index]; } 904 const TConstUnion& operator[](size_t index) const { return (*unionArray)[index]; } 905 bool operator==(const TConstUnionArray& rhs) const 906 { 907 // this includes the case that both are unallocated 908 if (unionArray == rhs.unionArray) 909 return true; 910 911 if (! unionArray || ! rhs.unionArray) 912 return false; 913 914 return *unionArray == *rhs.unionArray; 915 } 916 bool operator!=(const TConstUnionArray& rhs) const { return ! operator==(rhs); } 917 dot(const TConstUnionArray & rhs)918 double dot(const TConstUnionArray& rhs) 919 { 920 assert(rhs.unionArray->size() == unionArray->size()); 921 double sum = 0.0; 922 923 for (size_t comp = 0; comp < unionArray->size(); ++comp) 924 sum += (*this)[comp].getDConst() * rhs[comp].getDConst(); 925 926 return sum; 927 } 928 empty()929 bool empty() const { return unionArray == nullptr; } 930 931 protected: 932 typedef TVector<TConstUnion> TConstUnionVector; 933 TConstUnionVector* unionArray; 934 }; 935 936 } // end namespace glslang 937 938 #endif // _CONSTANT_UNION_INCLUDED_ 939