Line data    Source code

       1             : //
       2             : // Copyright (c) 2002-2016 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 COMPILER_TRANSLATOR_QUALIFIER_TYPES_H_
       8             : #define COMPILER_TRANSLATOR_QUALIFIER_TYPES_H_
       9             : 
      10             : #include "common/angleutils.h"
      11             : #include "compiler/translator/BaseTypes.h"
      12             : #include "compiler/translator/Types.h"
      13             : 
      14             : namespace sh
      15             : {
      16             : class TDiagnostics;
      17             : 
      18             : TLayoutQualifier JoinLayoutQualifiers(TLayoutQualifier leftQualifier,
      19             :                                       TLayoutQualifier rightQualifier,
      20             :                                       const TSourceLoc &rightQualifierLocation,
      21             :                                       TDiagnostics *diagnostics);
      22             : 
      23             : enum TQualifierType
      24             : {
      25             :     QtInvariant,
      26             :     QtInterpolation,
      27             :     QtLayout,
      28             :     QtStorage,
      29             :     QtPrecision,
      30             :     QtMemory
      31             : };
      32             : 
      33             : class TQualifierWrapperBase : angle::NonCopyable
      34             : {
      35             :   public:
      36           0 :     POOL_ALLOCATOR_NEW_DELETE();
      37           0 :     TQualifierWrapperBase(const TSourceLoc &line) : mLine(line) {}
      38           0 :     virtual ~TQualifierWrapperBase(){};
      39             :     virtual TQualifierType getType() const     = 0;
      40             :     virtual TString getQualifierString() const = 0;
      41             :     virtual unsigned int getRank() const       = 0;
      42           0 :     const TSourceLoc &getLine() const { return mLine; }
      43             :   private:
      44             :     TSourceLoc mLine;
      45             : };
      46             : 
      47             : class TInvariantQualifierWrapper final : public TQualifierWrapperBase
      48             : {
      49             :   public:
      50           0 :     TInvariantQualifierWrapper(const TSourceLoc &line) : TQualifierWrapperBase(line) {}
      51           0 :     ~TInvariantQualifierWrapper() {}
      52             : 
      53           0 :     TQualifierType getType() const { return QtInvariant; }
      54           0 :     TString getQualifierString() const { return "invariant"; }
      55             :     unsigned int getRank() const;
      56             : };
      57             : 
      58             : class TInterpolationQualifierWrapper final : public TQualifierWrapperBase
      59             : {
      60             :   public:
      61           0 :     TInterpolationQualifierWrapper(TQualifier interpolationQualifier, const TSourceLoc &line)
      62           0 :         : TQualifierWrapperBase(line), mInterpolationQualifier(interpolationQualifier)
      63             :     {
      64           0 :     }
      65           0 :     ~TInterpolationQualifierWrapper() {}
      66             : 
      67           0 :     TQualifierType getType() const { return QtInterpolation; }
      68           0 :     TString getQualifierString() const { return sh::getQualifierString(mInterpolationQualifier); }
      69           0 :     TQualifier getQualifier() const { return mInterpolationQualifier; }
      70             :     unsigned int getRank() const;
      71             : 
      72             :   private:
      73             :     TQualifier mInterpolationQualifier;
      74             : };
      75             : 
      76             : class TLayoutQualifierWrapper final : public TQualifierWrapperBase
      77             : {
      78             :   public:
      79           0 :     TLayoutQualifierWrapper(TLayoutQualifier layoutQualifier, const TSourceLoc &line)
      80           0 :         : TQualifierWrapperBase(line), mLayoutQualifier(layoutQualifier)
      81             :     {
      82           0 :     }
      83           0 :     ~TLayoutQualifierWrapper() {}
      84             : 
      85           0 :     TQualifierType getType() const { return QtLayout; }
      86           0 :     TString getQualifierString() const { return "layout"; }
      87           0 :     const TLayoutQualifier &getQualifier() const { return mLayoutQualifier; }
      88             :     unsigned int getRank() const;
      89             : 
      90             :   private:
      91             :     TLayoutQualifier mLayoutQualifier;
      92             : };
      93             : 
      94             : class TStorageQualifierWrapper final : public TQualifierWrapperBase
      95             : {
      96             :   public:
      97           0 :     TStorageQualifierWrapper(TQualifier storageQualifier, const TSourceLoc &line)
      98           0 :         : TQualifierWrapperBase(line), mStorageQualifier(storageQualifier)
      99             :     {
     100           0 :     }
     101           0 :     ~TStorageQualifierWrapper() {}
     102             : 
     103           0 :     TQualifierType getType() const { return QtStorage; }
     104           0 :     TString getQualifierString() const { return sh::getQualifierString(mStorageQualifier); }
     105           0 :     TQualifier getQualifier() const { return mStorageQualifier; }
     106             :     unsigned int getRank() const;
     107             : 
     108             :   private:
     109             :     TQualifier mStorageQualifier;
     110             : };
     111             : 
     112             : class TPrecisionQualifierWrapper final : public TQualifierWrapperBase
     113             : {
     114             :   public:
     115           0 :     TPrecisionQualifierWrapper(TPrecision precisionQualifier, const TSourceLoc &line)
     116           0 :         : TQualifierWrapperBase(line), mPrecisionQualifier(precisionQualifier)
     117             :     {
     118           0 :     }
     119           0 :     ~TPrecisionQualifierWrapper() {}
     120             : 
     121           0 :     TQualifierType getType() const { return QtPrecision; }
     122           0 :     TString getQualifierString() const { return sh::getPrecisionString(mPrecisionQualifier); }
     123           0 :     TPrecision getQualifier() const { return mPrecisionQualifier; }
     124             :     unsigned int getRank() const;
     125             : 
     126             :   private:
     127             :     TPrecision mPrecisionQualifier;
     128             : };
     129             : 
     130             : class TMemoryQualifierWrapper final : public TQualifierWrapperBase
     131             : {
     132             :   public:
     133           0 :     TMemoryQualifierWrapper(TQualifier memoryQualifier, const TSourceLoc &line)
     134           0 :         : TQualifierWrapperBase(line), mMemoryQualifier(memoryQualifier)
     135             :     {
     136           0 :     }
     137           0 :     ~TMemoryQualifierWrapper() {}
     138             : 
     139           0 :     TQualifierType getType() const { return QtMemory; }
     140           0 :     TString getQualifierString() const { return sh::getQualifierString(mMemoryQualifier); }
     141           0 :     TQualifier getQualifier() const { return mMemoryQualifier; }
     142             :     unsigned int getRank() const;
     143             : 
     144             :   private:
     145             :     TQualifier mMemoryQualifier;
     146             : };
     147             : 
     148             : // TTypeQualifier tightly covers type_qualifier from the grammar
     149             : struct TTypeQualifier
     150             : {
     151             :     // initializes all of the qualifiers and sets the scope
     152             :     TTypeQualifier(TQualifier scope, const TSourceLoc &loc);
     153             : 
     154             :     TLayoutQualifier layoutQualifier;
     155             :     TMemoryQualifier memoryQualifier;
     156             :     TPrecision precision;
     157             :     TQualifier qualifier;
     158             :     bool invariant;
     159             :     TSourceLoc line;
     160             : };
     161             : 
     162             : // TTypeQualifierBuilder contains all of the qualifiers when type_qualifier gets parsed.
     163             : // It is to be used to validate the qualifier sequence and build a TTypeQualifier from it.
     164             : class TTypeQualifierBuilder : angle::NonCopyable
     165             : {
     166             :   public:
     167             :     using QualifierSequence = TVector<const TQualifierWrapperBase *>;
     168             : 
     169             :   public:
     170           0 :     POOL_ALLOCATOR_NEW_DELETE();
     171             :     TTypeQualifierBuilder(const TStorageQualifierWrapper *scope, int shaderVersion);
     172             :     // Adds the passed qualifier to the end of the sequence.
     173             :     void appendQualifier(const TQualifierWrapperBase *qualifier);
     174             :     // Checks for the order of qualification and repeating qualifiers.
     175             :     bool checkSequenceIsValid(TDiagnostics *diagnostics) const;
     176             :     // Goes over the qualifier sequence and parses it to form a type qualifier for a function
     177             :     // parameter.
     178             :     // The returned object is initialized even if the parsing fails.
     179             :     TTypeQualifier getParameterTypeQualifier(TDiagnostics *diagnostics) const;
     180             :     // Goes over the qualifier sequence and parses it to form a type qualifier for a variable.
     181             :     // The returned object is initialized even if the parsing fails.
     182             :     TTypeQualifier getVariableTypeQualifier(TDiagnostics *diagnostics) const;
     183             : 
     184             :   private:
     185             :     QualifierSequence mQualifiers;
     186             :     int mShaderVersion;
     187             : };
     188             : 
     189             : }  // namespace sh
     190             : 
     191             : #endif  // COMPILER_TRANSLATOR_QUALIFIER_TYPES_H_