chromium/third_party/angle/src/compiler/translator/Types.cpp

//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

#if defined(_MSC_VER)
#    pragma warning(disable : 4718)
#endif

#include "compiler/translator/Types.h"
#include "compiler/translator/ImmutableString.h"
#include "compiler/translator/InfoSink.h"
#include "compiler/translator/IntermNode.h"
#include "compiler/translator/SymbolTable.h"

#include <algorithm>
#include <climits>

namespace sh
{

const char *getBasicString(TBasicType t)
{ … }

// TType implementation.
TType::TType() : … { … }

TType::TType(TBasicType t, uint8_t ps, uint8_t ss) : … { … }

TType::TType(TBasicType t, TPrecision p, TQualifier q, uint8_t ps, uint8_t ss)
    : … { … }

TType::TType(const TPublicType &p)
    : … { … }

TType::TType(const TStructure *userDef, bool isStructSpecifier)
    : … { … }

TType::TType(const TInterfaceBlock *interfaceBlockIn,
             TQualifier qualifierIn,
             TLayoutQualifier layoutQualifierIn)
    : … { … }

TType::TType(const TType &t)
{ … }

TType &TType::operator=(const TType &t)
{ … }

bool TType::canBeConstructed() const
{ … }

const char *TType::getBuiltInTypeNameString() const
{ … }

int TType::getDeepestStructNesting() const
{ … }

bool TType::isNamelessStruct() const
{ … }

bool TType::isStructureContainingArrays() const
{ … }

bool TType::isStructureContainingMatrices() const
{ … }

bool TType::isStructureContainingType(TBasicType t) const
{ … }

bool TType::isStructureContainingSamplers() const
{ … }

bool TType::isInterfaceBlockContainingType(TBasicType t) const
{ … }

bool TType::canReplaceWithConstantUnion() const
{ … }

//
// Recursively generate mangled names.
//
const char *TType::buildMangledName() const
{ … }

size_t TType::getObjectSize() const
{ … }

int TType::getLocationCount() const
{ … }

unsigned int TType::getArraySizeProduct() const
{ … }

bool TType::isUnsizedArray() const
{ … }

bool TType::sameNonArrayType(const TType &right) const
{ … }

bool TType::isElementTypeOf(const TType &arrayType) const
{ … }

void TType::sizeUnsizedArrays(const TSpan<const unsigned int> &newArraySizes)
{ … }

void TType::sizeOutermostUnsizedArray(unsigned int arraySize)
{ … }

void TType::setBasicType(TBasicType t)
{ … }

void TType::setPrimarySize(uint8_t ps)
{ … }

void TType::setSecondarySize(uint8_t ss)
{ … }

void TType::makeArray(unsigned int s)
{ … }

void TType::makeArrays(const TSpan<const unsigned int> &sizes)
{ … }

void TType::setArraySize(size_t arrayDimension, unsigned int s)
{ … }

void TType::toArrayElementType()
{ … }

void TType::toArrayBaseType()
{ … }

void TType::toMatrixColumnType()
{ … }

void TType::toComponentType()
{ … }

void TType::setInterfaceBlock(const TInterfaceBlock *interfaceBlockIn)
{ … }

void TType::setInterfaceBlockField(const TInterfaceBlock *interfaceBlockIn, size_t fieldIndex)
{ … }

const char *TType::getMangledName() const
{ … }

void TType::realize()
{ … }

void TType::createSamplerSymbols(const ImmutableString &namePrefix,
                                 const TString &apiNamePrefix,
                                 TVector<const TVariable *> *outputSymbols,
                                 TMap<const TVariable *, TString> *outputSymbolsToAPINames,
                                 TSymbolTable *symbolTable) const
{ … }

TFieldListCollection::TFieldListCollection(const TFieldList *fields)
    : … { … }

bool TFieldListCollection::containsArrays() const
{ … }

bool TFieldListCollection::containsMatrices() const
{ … }

bool TFieldListCollection::containsType(TBasicType type) const
{ … }

bool TFieldListCollection::containsSamplers() const
{ … }

TString TFieldListCollection::buildMangledFieldList() const
{ … }

size_t TFieldListCollection::calculateObjectSize() const
{ … }

size_t TFieldListCollection::objectSize() const
{ … }

int TFieldListCollection::getLocationCount() const
{ … }

int TFieldListCollection::deepestNesting() const
{ … }

const TString &TFieldListCollection::mangledFieldList() const
{ … }

int TFieldListCollection::calculateDeepestNesting() const
{ … }

// TPublicType implementation.
void TPublicType::initialize(const TTypeSpecifierNonArray &typeSpecifier, TQualifier q)
{ … }

void TPublicType::initializeBasicType(TBasicType basicType)
{ … }

bool TPublicType::isStructureContainingArrays() const
{ … }

bool TPublicType::isStructureContainingType(TBasicType t) const
{ … }

void TPublicType::setArraySizes(TVector<unsigned int> *sizes)
{ … }

bool TPublicType::isArray() const
{ … }

void TPublicType::clearArrayness()
{ … }

bool TPublicType::isAggregate() const
{ … }

}  // namespace sh