Renamed UnsignedInt to UInt in the compiler.

src/compiler/Intermediate.cpp

@@ -78,23 +78,23 @@ const char* getOperatorString(TOperator op) {
 
       // Fall-through.
       case EOpConvIntToBool:
-      case EOpConvUnsignedIntToBool:
+      case EOpConvUIntToBool:
       case EOpConvFloatToBool: return "bool";
  
       // Fall-through.
       case EOpConvBoolToFloat:
-      case EOpConvUnsignedIntToFloat:
+      case EOpConvUIntToFloat:
       case EOpConvIntToFloat: return "float";
  
       // Fall-through.
       case EOpConvFloatToInt:
-      case EOpConvUnsignedIntToInt:
+      case EOpConvUIntToInt:
       case EOpConvBoolToInt: return "int";
 
       // Fall-through.
-      case EOpConvIntToUnsignedInt:
-      case EOpConvFloatToUnsignedInt:
-      case EOpConvBoolToUnsignedInt: return "uint";
+      case EOpConvIntToUInt:
+      case EOpConvFloatToUInt:
+      case EOpConvBoolToUInt: return "uint";
 
       case EOpRadians: return "radians";
       case EOpDegrees: return "degrees";
@@ -324,7 +324,7 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode,
     TBasicType newType = EbtVoid;
     switch (op) {
         case EOpConstructInt:   newType = EbtInt;   break;
-        case EOpConstructUnsignedInt: newType = EbtUInt; break;
+        case EOpConstructUInt:  newType = EbtUInt;  break;
         case EOpConstructBool:  newType = EbtBool;  break;
         case EOpConstructFloat: newType = EbtFloat; break;
         default: break;
@@ -345,7 +345,7 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode,
     //
     switch (op) {
         case EOpConstructInt:
-        case EOpConstructUnsignedInt:
+        case EOpConstructUInt:
         case EOpConstructBool:
         case EOpConstructFloat:
             return child;
@@ -473,7 +473,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         case EOpConstructInt:
             promoteTo = EbtInt;
             break;
-        case EOpConstructUnsignedInt:
+        case EOpConstructUInt:
             promoteTo = EbtUInt;
             break;
         default:
@@ -503,9 +503,9 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         switch (promoteTo) {
             case EbtFloat:
                 switch (node->getBasicType()) {
-                    case EbtInt:    newOp = EOpConvIntToFloat;         break;
-                    case EbtUInt:   newOp = EOpConvFloatToUnsignedInt; break;
-                    case EbtBool:   newOp = EOpConvBoolToFloat;        break;
+                    case EbtInt:    newOp = EOpConvIntToFloat;  break;
+                    case EbtUInt:   newOp = EOpConvFloatToUInt; break;
+                    case EbtBool:   newOp = EOpConvBoolToFloat; break;
                     default:
                         infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
                         return 0;
@@ -513,9 +513,9 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
                 break;
             case EbtBool:
                 switch (node->getBasicType()) {
-                    case EbtInt:    newOp = EOpConvIntToBool;         break;
-                    case EbtUInt:   newOp = EOpConvBoolToUnsignedInt; break;
-                    case EbtFloat:  newOp = EOpConvFloatToBool;       break;
+                    case EbtInt:    newOp = EOpConvIntToBool;   break;
+                    case EbtUInt:   newOp = EOpConvBoolToUInt;  break;
+                    case EbtFloat:  newOp = EOpConvFloatToBool; break;
                     default:
                         infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
                         return 0;
@@ -523,9 +523,9 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
                 break;
             case EbtInt:
                 switch (node->getBasicType()) {
-                    case EbtUInt:   newOp = EOpConvUnsignedIntToInt; break;
-                    case EbtBool:   newOp = EOpConvBoolToInt;        break;
-                    case EbtFloat:  newOp = EOpConvFloatToInt;       break;
+                    case EbtUInt:   newOp = EOpConvUIntToInt;  break;
+                    case EbtBool:   newOp = EOpConvBoolToInt;  break;
+                    case EbtFloat:  newOp = EOpConvFloatToInt; break;
                     default:
                         infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
                         return 0;
@@ -533,9 +533,9 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
                 break;
             case EbtUInt:
                 switch (node->getBasicType()) {
-                    case EbtInt:    newOp = EOpConvIntToUnsignedInt;   break;
-                    case EbtBool:   newOp = EOpConvBoolToUnsignedInt;  break;
-                    case EbtFloat:  newOp = EOpConvFloatToUnsignedInt; break;
+                    case EbtInt:    newOp = EOpConvIntToUInt;   break;
+                    case EbtBool:   newOp = EOpConvBoolToUInt;  break;
+                    case EbtFloat:  newOp = EOpConvFloatToUInt; break;
                     default:
                         infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
                         return 0;
@@ -833,7 +833,7 @@ bool TIntermOperator::isConstructor() const
         case EOpConstructUVec2:
         case EOpConstructUVec3:
         case EOpConstructUVec4:
-        case EOpConstructUnsignedInt:
+        case EOpConstructUInt:
         case EOpConstructBVec2:
         case EOpConstructBVec3:
         case EOpConstructBVec4:

src/compiler/OutputHLSL.cpp

@@ -1716,7 +1716,7 @@ bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node)
       case EOpPreIncrement:     outputTriplet(visit, "(++", "", ")"); break;
       case EOpPreDecrement:     outputTriplet(visit, "(--", "", ")"); break;
       case EOpConvIntToBool:
-      case EOpConvUnsignedIntToBool:
+      case EOpConvUIntToBool:
       case EOpConvFloatToBool:
         switch (node->getOperand()->getType().getNominalSize())
         {
@@ -1729,7 +1729,7 @@ bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node)
         break;
       case EOpConvBoolToFloat:
       case EOpConvIntToFloat:
-      case EOpConvUnsignedIntToFloat:
+      case EOpConvUIntToFloat:
         switch (node->getOperand()->getType().getNominalSize())
         {
           case 1:    outputTriplet(visit, "float(", "", ")");  break;
@@ -1741,7 +1741,7 @@ bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node)
         break;
       case EOpConvFloatToInt:
       case EOpConvBoolToInt:
-      case EOpConvUnsignedIntToInt:
+      case EOpConvUIntToInt:
         switch (node->getOperand()->getType().getNominalSize())
         {
           case 1:    outputTriplet(visit, "int(", "", ")");  break;
@@ -1751,9 +1751,9 @@ bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node)
           default: UNREACHABLE();
         }
         break;
-      case EOpConvFloatToUnsignedInt:
-      case EOpConvBoolToUnsignedInt:
-      case EOpConvIntToUnsignedInt:
+      case EOpConvFloatToUInt:
+      case EOpConvBoolToUInt:
+      case EOpConvIntToUInt:
         switch (node->getOperand()->getType().getCols())
         {
           case 1:    outputTriplet(visit, "uint(", "", ")");  break;
@@ -2252,7 +2252,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
         addConstructor(node->getType(), "ivec4", &node->getSequence());
         outputTriplet(visit, "ivec4(", ", ", ")");
         break;
-      case EOpConstructUnsignedInt:
+      case EOpConstructUInt:
         addConstructor(node->getType(), "uvec1", &node->getSequence());
         outputTriplet(visit, "uvec1(", "", ")");
         break;

src/compiler/ParseHelper.cpp

@@ -1214,7 +1214,7 @@ TFunction *TParseContext::addConstructorFunc(TPublicType publicType)
           case EbtUInt:
             switch(publicType.getNominalSize())
             {
-              case 1:       op = EOpConstructUnsignedInt;   break;
+              case 1:       op = EOpConstructUInt;  break;
               case 2:       op = EOpConstructUVec2; break;
               case 3:       op = EOpConstructUVec3; break;
               case 4:       op = EOpConstructUVec4; break;
@@ -1390,8 +1390,8 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType* type, TOperator op, T
     case EOpConstructUVec2:
     case EOpConstructUVec3:
     case EOpConstructUVec4:
-    case EOpConstructUnsignedInt:
-        basicOp = EOpConstructUnsignedInt;
+    case EOpConstructUInt:
+        basicOp = EOpConstructUInt;
         break;
 
     case EOpConstructBVec2:

src/compiler/intermOut.cpp

@@ -154,16 +154,16 @@ bool TOutputTraverser::visitUnary(Visit visit, TIntermUnary* node)
         case EOpPreDecrement:   out << "Pre-Decrement";        break;
 
         case EOpConvIntToBool:  out << "Convert int to bool";  break;
-        case EOpConvUnsignedIntToBool:  out << "Convert unsigned int to bool";  break;
+        case EOpConvUIntToBool: out << "Convert uint to bool"; break;
         case EOpConvFloatToBool:out << "Convert float to bool";break;
         case EOpConvBoolToFloat:out << "Convert bool to float";break;
         case EOpConvIntToFloat: out << "Convert int to float"; break;
-        case EOpConvUnsignedIntToFloat: out << "Convert unsigned int to float"; break;
+        case EOpConvUIntToFloat:out << "Convert uint to float";break;
         case EOpConvFloatToInt: out << "Convert float to int"; break;
         case EOpConvBoolToInt:  out << "Convert bool to int";  break;
-        case EOpConvIntToUnsignedInt: out << "Convert int to unsigned int"; break;
-        case EOpConvFloatToUnsignedInt: out << "Convert float to unsigned int"; break;
-        case EOpConvBoolToUnsignedInt:  out << "Convert bool to unsigned int";  break;
+        case EOpConvIntToUInt:  out << "Convert int to uint";  break;
+        case EOpConvFloatToUInt:out << "Convert float to uint";break;
+        case EOpConvBoolToUInt: out << "Convert bool to uint"; break;
 
         case EOpRadians:        out << "radians";              break;
         case EOpDegrees:        out << "degrees";              break;
@@ -236,7 +236,7 @@ bool TOutputTraverser::visitAggregate(Visit visit, TIntermAggregate* node)
         case EOpConstructIVec2: out << "Construct ivec2"; break;
         case EOpConstructIVec3: out << "Construct ivec3"; break;
         case EOpConstructIVec4: out << "Construct ivec4"; break;
-        case EOpConstructUnsignedInt:   out << "Construct uint";   break;
+        case EOpConstructUInt:  out << "Construct uint";  break;
         case EOpConstructMat2:  out << "Construct mat2";  break;
         case EOpConstructMat3:  out << "Construct mat3";  break;
         case EOpConstructMat4:  out << "Construct mat4";  break;

src/compiler/intermediate.h

@@ -49,17 +49,17 @@ enum TOperator {
     EOpPreDecrement,
 
     EOpConvIntToBool,
-    EOpConvUnsignedIntToBool,
+    EOpConvUIntToBool,
     EOpConvFloatToBool,
     EOpConvBoolToFloat,
     EOpConvIntToFloat,
-    EOpConvUnsignedIntToFloat,
+    EOpConvUIntToFloat,
     EOpConvFloatToInt,
     EOpConvBoolToInt,
-    EOpConvUnsignedIntToInt,
-    EOpConvIntToUnsignedInt,
-    EOpConvFloatToUnsignedInt,
-    EOpConvBoolToUnsignedInt,
+    EOpConvUIntToInt,
+    EOpConvIntToUInt,
+    EOpConvFloatToUInt,
+    EOpConvBoolToUInt,
 
     //
     // binary operations
@@ -161,7 +161,7 @@ enum TOperator {
     //
 
     EOpConstructInt,
-    EOpConstructUnsignedInt,
+    EOpConstructUInt,
     EOpConstructBool,
     EOpConstructFloat,
     EOpConstructVec2,