chromium/third_party/angle/src/compiler/translator/SymbolTable.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.
//
// Symbol table for parsing. The design principles and most of the functionality are documented in
// the header file.
//

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

#include "compiler/translator/SymbolTable.h"

#include "angle_gl.h"
#include "compiler/translator/ImmutableString.h"
#include "compiler/translator/IntermNode.h"
#include "compiler/translator/StaticType.h"
#include "compiler/translator/util.h"

namespace sh
{
namespace
{
bool CheckShaderType(Shader expected, GLenum actual)
{ … }

bool CheckExtension(uint32_t extensionIndex, const ShBuiltInResources &resources)
{ … }
}  // namespace

class TSymbolTable::TSymbolTableLevel
{ … };

bool TSymbolTable::TSymbolTableLevel::insert(TSymbol *symbol)
{ … }

void TSymbolTable::TSymbolTableLevel::insertUnmangled(TFunction *function)
{ … }

TSymbol *TSymbolTable::TSymbolTableLevel::find(const ImmutableString &name) const
{ … }

TSymbolTable::TSymbolTable()
    : … { … }

TSymbolTable::~TSymbolTable() = default;

bool TSymbolTable::isEmpty() const
{ … }

bool TSymbolTable::atGlobalLevel() const
{ … }

void TSymbolTable::push()
{ … }

void TSymbolTable::pop()
{ … }

const TFunction *TSymbolTable::markFunctionHasPrototypeDeclaration(
    const ImmutableString &mangledName,
    bool *hadPrototypeDeclarationOut) const
{ … }

const TFunction *TSymbolTable::setFunctionParameterNamesFromDefinition(const TFunction *function,
                                                                       bool *wasDefinedOut) const
{ … }

bool TSymbolTable::setGlInArraySize(unsigned int inputArraySize)
{ … }

TVariable *TSymbolTable::getGlInVariableWithArraySize() const
{ … }

const TVariable *TSymbolTable::gl_FragData() const
{ … }

const TVariable *TSymbolTable::gl_SecondaryFragDataEXT() const
{ … }

TSymbolTable::VariableMetadata *TSymbolTable::getOrCreateVariableMetadata(const TVariable &variable)
{ … }

void TSymbolTable::markStaticWrite(const TVariable &variable)
{ … }

void TSymbolTable::markStaticRead(const TVariable &variable)
{ … }

bool TSymbolTable::isStaticallyUsed(const TVariable &variable) const
{ … }

void TSymbolTable::addInvariantVarying(const TVariable &variable)
{ … }

bool TSymbolTable::isVaryingInvariant(const TVariable &variable) const
{ … }

void TSymbolTable::setGlobalInvariant(bool invariant)
{ … }

const TSymbol *TSymbolTable::find(const ImmutableString &name, int shaderVersion) const
{ … }

const TSymbol *TSymbolTable::findUserDefined(const ImmutableString &name) const
{ … }

TFunction *TSymbolTable::findUserDefinedFunction(const ImmutableString &name) const
{ … }

const TSymbol *TSymbolTable::findGlobal(const ImmutableString &name) const
{ … }

const TSymbol *TSymbolTable::findGlobalWithConversion(
    const std::vector<ImmutableString> &names) const
{ … }

const TSymbol *TSymbolTable::findBuiltInWithConversion(const std::vector<ImmutableString> &names,
                                                       int shaderVersion) const
{ … }

bool TSymbolTable::declare(TSymbol *symbol)
{ … }

bool TSymbolTable::declareInternal(TSymbol *symbol)
{ … }

void TSymbolTable::declareUserDefinedFunction(TFunction *function, bool insertUnmangledName)
{ … }

void TSymbolTable::setDefaultPrecision(TBasicType type, TPrecision prec)
{ … }

TPrecision TSymbolTable::getDefaultPrecision(TBasicType type) const
{ … }

void TSymbolTable::clearCompilationResults()
{ … }

int TSymbolTable::nextUniqueIdValue()
{ … }

void TSymbolTable::initializeBuiltIns(sh::GLenum type,
                                      ShShaderSpec spec,
                                      const ShBuiltInResources &resources)
{ … }

void TSymbolTable::initSamplerDefaultPrecision(TBasicType samplerType)
{ … }

TSymbolTable::VariableMetadata::VariableMetadata()
    : … { … }

const TSymbol *SymbolRule::get(ShShaderSpec shaderSpec,
                               int shaderVersion,
                               sh::GLenum shaderType,
                               const ShBuiltInResources &resources,
                               const TSymbolTableBase &symbolTable) const
{ … }

const TSymbol *FindMangledBuiltIn(ShShaderSpec shaderSpec,
                                  int shaderVersion,
                                  sh::GLenum shaderType,
                                  const ShBuiltInResources &resources,
                                  const TSymbolTableBase &symbolTable,
                                  const SymbolRule *rules,
                                  uint16_t startIndex,
                                  uint16_t endIndex)
{ … }

bool UnmangledEntry::matches(const ImmutableString &name,
                             ShShaderSpec shaderSpec,
                             int shaderVersion,
                             sh::GLenum shaderType,
                             const TExtensionBehavior &extensions) const
{ … }
}  // namespace sh