Add GLSL sampler types to semantic analysis phase

src/libs/glsl/glsl.h

@@ -62,6 +62,7 @@ class IndexType;
 class VectorType;
 class MatrixType;
 class ArrayType;
+class SamplerType;
 
 // symbols
 class Symbol;

src/libs/glsl/glslengine.cpp

@@ -30,6 +30,7 @@
 #include "glslengine.h"
 #include "glslsymbols.h"
 #include "glsltypes.h"
+#include "glslparser.h"
 
 using namespace GLSL;
 
@@ -144,6 +145,10 @@ const DoubleType *Engine::doubleType()
     return &t;
 }
 
+const SamplerType *Engine::samplerType(int kind)
+{
+    return _samplerTypes.intern(SamplerType(kind));
+}
 
 const VectorType *Engine::vectorType(const Type *elementType, int dimension)
 {

src/libs/glsl/glslengine.h

@@ -106,6 +106,7 @@ public:
     const UIntType *uintType();
     const FloatType *floatType();
     const DoubleType *doubleType();
+    const SamplerType *samplerType(int kind);
     const VectorType *vectorType(const Type *elementType, int dimension);
     const MatrixType *matrixType(const Type *elementType, int columns, int rows);
 
@@ -126,6 +127,7 @@ private:
     QSet<QString> _identifiers;
     TypeTable<VectorType> _vectorTypes;
     TypeTable<MatrixType> _matrixTypes;
+    TypeTable<SamplerType> _samplerTypes;
     MemoryPool _pool;
     QList<DiagnosticMessage> _diagnosticMessages;
     QList<Symbol *> _symbols;

src/libs/glsl/glslsemantic.cpp

@@ -464,6 +464,50 @@ bool Semantic::visit(BasicTypeAST *ast)
         _type = _engine->matrixType(_engine->doubleType(), 4, 4);
         break;
 
+    // samplers
+    case Parser::T_SAMPLER1D:
+    case Parser::T_SAMPLER2D:
+    case Parser::T_SAMPLER3D:
+    case Parser::T_SAMPLERCUBE:
+    case Parser::T_SAMPLER1DSHADOW:
+    case Parser::T_SAMPLER2DSHADOW:
+    case Parser::T_SAMPLERCUBESHADOW:
+    case Parser::T_SAMPLER1DARRAY:
+    case Parser::T_SAMPLER2DARRAY:
+    case Parser::T_SAMPLER1DARRAYSHADOW:
+    case Parser::T_SAMPLER2DARRAYSHADOW:
+    case Parser::T_SAMPLERCUBEARRAY:
+    case Parser::T_SAMPLERCUBEARRAYSHADOW:
+    case Parser::T_SAMPLER2DRECT:
+    case Parser::T_SAMPLER2DRECTSHADOW:
+    case Parser::T_SAMPLERBUFFER:
+    case Parser::T_SAMPLER2DMS:
+    case Parser::T_SAMPLER2DMSARRAY:
+    case Parser::T_ISAMPLER1D:
+    case Parser::T_ISAMPLER2D:
+    case Parser::T_ISAMPLER3D:
+    case Parser::T_ISAMPLERCUBE:
+    case Parser::T_ISAMPLER1DARRAY:
+    case Parser::T_ISAMPLER2DARRAY:
+    case Parser::T_ISAMPLERCUBEARRAY:
+    case Parser::T_ISAMPLER2DRECT:
+    case Parser::T_ISAMPLERBUFFER:
+    case Parser::T_ISAMPLER2DMS:
+    case Parser::T_ISAMPLER2DMSARRAY:
+    case Parser::T_USAMPLER1D:
+    case Parser::T_USAMPLER2D:
+    case Parser::T_USAMPLER3D:
+    case Parser::T_USAMPLERCUBE:
+    case Parser::T_USAMPLER1DARRAY:
+    case Parser::T_USAMPLER2DARRAY:
+    case Parser::T_USAMPLERCUBEARRAY:
+    case Parser::T_USAMPLER2DRECT:
+    case Parser::T_USAMPLERBUFFER:
+    case Parser::T_USAMPLER2DMS:
+    case Parser::T_USAMPLER2DMSARRAY:
+        _type = _engine->samplerType(ast->token);
+        break;
+
     default:
         qDebug() << "unknown type:" << GLSLParserTable::spell[ast->token];
     }

src/libs/glsl/glsltype.h

@@ -50,6 +50,7 @@ public:
     virtual const VectorType *asVectorType() const { return 0; }
     virtual const MatrixType *asMatrixType() const { return 0; }
     virtual const ArrayType *asArrayType() const { return 0; }
+    virtual const SamplerType *asSamplerType() const { return 0; }
 
     virtual const Struct *asStructType() const { return 0; }
     virtual const Function *asFunctionType() const { return 0; }

src/libs/glsl/glsltypes.cpp

@@ -373,3 +373,20 @@ Symbol *Function::find(const QString &name) const
     }
     return 0;
 }
+
+bool SamplerType::isEqualTo(const Type *other) const
+{
+    if (other) {
+        if (const SamplerType *samp = other->asSamplerType())
+            return _kind == samp->kind();
+    }
+    return false;
+}
+
+bool SamplerType::isLessThan(const Type *other) const
+{
+    Q_ASSERT(other != 0);
+    const SamplerType *samp = other->asSamplerType();
+    Q_ASSERT(samp != 0);
+    return _kind < samp->kind();
+}

src/libs/glsl/glsltypes.h

@@ -233,6 +233,22 @@ private:
     QVector<Argument *> _arguments;
 };
 
+class GLSL_EXPORT SamplerType: public Type
+{
+public:
+    explicit SamplerType(int kind) : _kind(kind) {}
+
+    // Kind of sampler as a token code; e.g. T_SAMPLER2D.
+    int kind() const { return _kind; }
+
+    virtual const SamplerType *asSamplerType() const { return this; }
+    virtual bool isEqualTo(const Type *other) const;
+    virtual bool isLessThan(const Type *other) const;
+
+private:
+    int _kind;
+};
+
 } // end of namespace GLSL
 
 #endif // GLSLTYPES_H