Array of Array prep: Turn a batch of 0's into nullptr or UnsizedArraySize.

glslang/Include/ConstantUnion.h

@@ -419,13 +419,13 @@ class TConstUnionArray {
 public:
     POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
 
-    TConstUnionArray() : unionArray(0) { }
+    TConstUnionArray() : unionArray(nullptr) { }
     virtual ~TConstUnionArray() { }
 
     explicit TConstUnionArray(int size)
     {
         if (size == 0)
-            unionArray = 0;
+            unionArray = nullptr;
         else
             unionArray =  new TConstUnionVector(size);
     }
@@ -473,7 +473,7 @@ public:
         return sum;
     }
 
-    bool empty() const { return unionArray == 0; }
+    bool empty() const { return unionArray == nullptr; }
 
 protected:
     typedef TVector<TConstUnion> TConstUnionVector;

glslang/Include/Types.h

@@ -804,8 +804,8 @@ public:
         vectorSize = 1;
         matrixRows = 0;
         matrixCols = 0;
-        arraySizes = 0;
-        userDef = 0;
+        arraySizes = nullptr;
+        userDef = nullptr;
         loc = l;
     }
 
@@ -840,7 +840,7 @@ public:
 
     bool isScalar() const
     {
-        return matrixCols == 0 && vectorSize == 1 && arraySizes == 0 && userDef == 0;
+        return matrixCols == 0 && vectorSize == 1 && arraySizes == nullptr && userDef == nullptr;
     }
 
     bool isImage() const
@@ -858,8 +858,8 @@ public:
 
     // for "empty" type (no args) or simple scalar/vector/matrix
     explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0) :
-                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), arraySizes(0),
-                            structure(0), fieldName(0), typeName(0)
+                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), arraySizes(nullptr),
+                            structure(nullptr), fieldName(nullptr), typeName(nullptr)
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -867,8 +867,8 @@ public:
                             }
     // for explicit precision qualifier
     TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0) :
-                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), arraySizes(0),
-                            structure(0), fieldName(0), typeName(0)
+                            basicType(t), vectorSize(vs), matrixCols(mc), matrixRows(mr), arraySizes(nullptr),
+                            structure(nullptr), fieldName(nullptr), typeName(nullptr)
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -879,7 +879,7 @@ public:
     // for turning a TPublicType into a TType
     explicit TType(const TPublicType& p) :
                             basicType(p.basicType), vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), arraySizes(p.arraySizes),
-                            structure(0), fieldName(0), typeName(0)
+                            structure(nullptr), fieldName(nullptr), typeName(nullptr)
                             {
                                 if (basicType == EbtSampler)
                                     sampler = p.sampler;
@@ -910,7 +910,7 @@ public:
     // for making structures, ...
     TType(TTypeList* userDef, const TString& n) :
                             basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0),
-                            arraySizes(0), structure(userDef), fieldName(0)
+                            arraySizes(nullptr), structure(userDef), fieldName(nullptr)
                             {
                                 sampler.clear();
                                 qualifier.clear();
@@ -919,7 +919,7 @@ public:
     // For interface blocks
     TType(TTypeList* userDef, const TString& n, const TQualifier& q) : 
                             basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0),
-                            qualifier(q), arraySizes(0), structure(userDef), fieldName(0)
+                            qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr)
                             {
                                 sampler.clear();
                                 typeName = NewPoolTString(n.c_str());
@@ -1000,7 +1000,7 @@ public:
     virtual void dereference(bool rowMajor = false)
     {
         if (arraySizes)
-            arraySizes = 0;
+            arraySizes = nullptr;
         else if (matrixCols > 0) {
             if (rowMajor)
                 vectorSize = matrixCols;
@@ -1039,17 +1039,17 @@ public:
     virtual int getMatrixCols() const { return matrixCols; }
     virtual int getMatrixRows() const { return matrixRows; }
     virtual int getArraySize()  const { return arraySizes->getOuterSize(); }
-    virtual bool isArrayOfArrays() const { return arraySizes && arraySizes->getNumDims() > 1; }
+    virtual bool isArrayOfArrays() const { return arraySizes != nullptr && arraySizes->getNumDims() > 1; }
     virtual int getImplicitArraySize() const { return arraySizes->getImplicitSize(); }
 
     virtual bool isScalar() const { return vectorSize == 1 && ! isStruct() && ! isArray(); }
     virtual bool isVector() const { return vectorSize > 1; }
     virtual bool isMatrix() const { return matrixCols ? true : false; }
-    virtual bool isArray()  const { return arraySizes != 0; }
-    virtual bool isImplicitlySizedArray() const { return isArray() && ! getArraySize() && qualifier.storage != EvqBuffer; }
-    virtual bool isExplicitlySizedArray() const { return isArray() && getArraySize(); }
-    virtual bool isRuntimeSizedArray() const { return isArray() && ! getArraySize() && qualifier.storage == EvqBuffer; }
-    virtual bool isStruct() const { return structure != 0; }
+    virtual bool isArray()  const { return arraySizes != nullptr; }
+    virtual bool isExplicitlySizedArray() const { return isArray() && getArraySize() != UnsizedArraySize; }
+    virtual bool isImplicitlySizedArray() const { return isArray() && getArraySize() == UnsizedArraySize && qualifier.storage != EvqBuffer; }
+    virtual bool isRuntimeSizedArray()    const { return isArray() && getArraySize() == UnsizedArraySize && qualifier.storage == EvqBuffer; }
+    virtual bool isStruct() const { return structure != nullptr; }
     virtual bool isImage() const { return basicType == EbtSampler && getSampler().image; }
 
     // Recursively checks if the type contains the given basic type
@@ -1071,7 +1071,7 @@ public:
     {
         if (isArray())
             return true;
-        if (! structure)
+        if (structure == nullptr)
             return false;
         for (unsigned int i = 0; i < structure->size(); ++i) {
             if ((*structure)[i].type->containsArray())
@@ -1083,7 +1083,7 @@ public:
     // Check the structure for any structures, needed for some error checks
     virtual bool containsStructure() const
     {
-        if (! structure)
+        if (structure == nullptr)
             return false;
         for (unsigned int i = 0; i < structure->size(); ++i) {
             if ((*structure)[i].type->structure)
@@ -1097,7 +1097,7 @@ public:
     {
         if (isImplicitlySizedArray())
             return true;
-        if (! structure)
+        if (structure == nullptr)
             return false;
         for (unsigned int i = 0; i < structure->size(); ++i) {
             if ((*structure)[i].type->containsImplicitlySizedArray())
@@ -1242,11 +1242,10 @@ public:
             p += snprintf(p, end - p, "writeonly ");
         p += snprintf(p, end - p, "%s ", getStorageQualifierString());
         if (arraySizes) {
-            if (arraySizes->getOuterSize() == 0) {
+            if (arraySizes->getOuterSize() == UnsizedArraySize) {
                 p += snprintf(p, end - p, "implicitly-sized array of ");
             } else {
                 for(int i = 0; i < (int)arraySizes->getNumDims() ; ++i) {
-//                    p += snprintf(p, end - p, "%s%d", (i == 0 ? "" : "x"), arraySizes->sizes[numDimensions-1-i]);
                     p += snprintf(p, end - p, "%d-element array of ", (*arraySizes)[i]);
                 }
             }
@@ -1337,12 +1336,12 @@ public:
     //
     bool sameStructType(const TType& right) const
     {
-        // Most commonly, they are both 0, or the same pointer to the same actual structure
+        // Most commonly, they are both nullptr, or the same pointer to the same actual structure
         if (structure == right.structure)
             return true;
 
-        // Both being 0 was caught above, now they both have to be structures of the same number of elements
-        if (structure == 0 || right.structure == 0 ||
+        // Both being nullptr was caught above, now they both have to be structures of the same number of elements
+        if (structure == nullptr || right.structure == nullptr ||
             structure->size() != right.structure->size())
             return false;
 
@@ -1371,7 +1370,7 @@ public:
     // See if two type's arrayness match
     bool sameArrayness(const TType& right) const
     {
-        return ((arraySizes == 0 && right.arraySizes == 0) ||
+        return ((arraySizes == nullptr && right.arraySizes == nullptr) ||
                 (arraySizes && right.arraySizes && *arraySizes == *right.arraySizes));
     }
 
@@ -1410,8 +1409,8 @@ protected:
     TSampler sampler;
     TQualifier qualifier;
 
-    TArraySizes* arraySizes;    // 0 unless an array; can be shared across types
-    TTypeList* structure;       // 0 unless this is a struct; can be shared across types
+    TArraySizes* arraySizes;    // nullptr unless an array; can be shared across types
+    TTypeList* structure;       // nullptr unless this is a struct; can be shared across types
     TString *fieldName;         // for structure field names
     TString *typeName;          // for structure type name
 };

glslang/Include/arrays.h

@@ -43,6 +43,10 @@
 
 namespace glslang {
 
+// This is used to mean there is no size yet, it is waiting to get a size from somewhere else.
+// Historically, this is not fully encapsulated, trying to catch them all...
+const int UnsizedArraySize = 0;
+
 //
 // TSmallArrayVector is used as the container for the set of sizes in TArraySizes.
 // It has generic-container semantics, while TArraySizes has array-of-array semantics.
@@ -56,7 +60,7 @@ struct TSmallArrayVector {
     //
     POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
 
-    TSmallArrayVector() : sizes(0) { }
+    TSmallArrayVector() : sizes(nullptr) { }
     virtual ~TSmallArrayVector() { dealloc(); }
 
     // For breaking into two non-shared copies, independently modifiable.
@@ -72,14 +76,14 @@ struct TSmallArrayVector {
         return *this;
     }
 
-    int size()
+    int size() const
     {
         if (sizes == nullptr)
             return 0;
         return (int)sizes->size();
     }
 
-    unsigned int front()
+    unsigned int front() const
     {
         assert(sizes != nullptr && sizes->size() > 0);
         return sizes->front();
@@ -97,13 +101,13 @@ struct TSmallArrayVector {
         sizes->push_back(e);
     }
 
-    unsigned int operator[](int i)
+    unsigned int operator[](int i) const
     {
         assert(sizes && (int)sizes->size() > i);
         return (*sizes)[i];
     }
 
-    bool operator==(const TSmallArrayVector& rhs)
+    bool operator==(const TSmallArrayVector& rhs) const
     {
         if (sizes == nullptr && rhs.sizes == nullptr)
             return true;
@@ -150,14 +154,14 @@ struct TArraySizes {
     }
 
     // translate from array-of-array semantics to container semantics
-    int getNumDims() { return sizes.size(); }
-    int getOuterSize() { return sizes.front(); }
+    int getNumDims() const { return sizes.size(); }
+    int getOuterSize() const { return sizes.front(); }
     void setOuterSize(int s) { sizes.push_back((unsigned)s); }
     void changeOuterSize(int s) { sizes.changeFront((unsigned)s); }
-    int getImplicitSize() { return (int)implicitArraySize; }
+    int getImplicitSize() const { return (int)implicitArraySize; }
     void setImplicitSize(int s) { implicitArraySize = s; }
-    int operator[](int i) { return sizes[i]; }
-    bool operator==(const TArraySizes& rhs) { return sizes == rhs.sizes; }
+    int operator[](int i) const { return sizes[i]; }
+    bool operator==(const TArraySizes& rhs) const { return sizes == rhs.sizes; }
 
 protected:
     TSmallArrayVector sizes;

glslang/Include/revision.h

@@ -2,5 +2,5 @@
 // For the version, it uses the latest git tag followed by the number of commits.
 // For the date, it uses the current date (when then script is run).
 
-#define GLSLANG_REVISION "2.3.704"
-#define GLSLANG_DATE "06-Aug-2015"
+#define GLSLANG_REVISION "2.3.706"
+#define GLSLANG_DATE "09-Aug-2015"

glslang/MachineIndependent/Scan.cpp

@@ -295,8 +295,8 @@ namespace {
 
 // A single global usable by all threads, by all versions, by all languages.
 // After a single process-level initialization, this is read only and thread safe
-std::unordered_map<std::string, int>* KeywordMap = 0;
-std::unordered_set<std::string>* ReservedSet = 0;
+std::unordered_map<std::string, int>* KeywordMap = nullptr;
+std::unordered_set<std::string>* ReservedSet = nullptr;
 
 };
 
@@ -304,7 +304,7 @@ namespace glslang {
 
 void TScanContext::fillInKeywordMap()
 {
-    if (KeywordMap != 0) {
+    if (KeywordMap != nullptr) {
         // this is really an error, as this should called only once per process
         // but, the only risk is if two threads called simultaneously
         return;
@@ -522,9 +522,9 @@ void TScanContext::fillInKeywordMap()
 void TScanContext::deleteKeywordMap()
 {
     delete KeywordMap;
-    KeywordMap = 0;
+    KeywordMap = nullptr;
     delete ReservedSet;
-    ReservedSet = 0;
+    ReservedSet = nullptr;
 }
 
 int TScanContext::tokenize(TPpContext* pp, TParserToken& token)
@@ -533,7 +533,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token)
         parserToken = &token;
         TPpToken ppToken;
         tokenText = pp->tokenize(&ppToken);
-        if (tokenText == 0)
+        if (tokenText == nullptr)
             return 0;
 
         loc = ppToken.loc;

glslang/MachineIndependent/limits.cpp

@@ -133,7 +133,7 @@ void TParseContext::inductiveLoopBodyCheck(TIntermNode* body, int loopId, TSymbo
 {
     TInductiveTraverser it(loopId, symbolTable);
 
-    if (! body)
+    if (body == nullptr)
         return;
 
     body->traverse(&it);