SkSL::SymbolTable Class Reference

#include <SkSLSymbolTable.h>

Public Member Functions
	SymbolTable (bool builtin)
	SymbolTable (SymbolTable *parent, bool builtin)
std::unique_ptr< SymbolTable >	insertNewParent ()
const Symbol *	find (std::string_view name) const
const Symbol *	findBuiltinSymbol (std::string_view name) const
Symbol *	findMutable (std::string_view name) const
std::unique_ptr< Expression >	instantiateSymbolRef (const Context &context, std::string_view name, Position pos)
void	renameSymbol (const Context &context, Symbol *symbol, std::string_view newName)
std::unique_ptr< Symbol >	removeSymbol (const Symbol *symbol)
void	moveSymbolTo (SymbolTable *otherTable, Symbol *sym, const Context &context)
bool	isType (std::string_view name) const
bool	isBuiltinType (std::string_view name) const
void	addWithoutOwnershipOrDie (Symbol *symbol)
void	addWithoutOwnership (const Context &context, Symbol *symbol)
template<typename T >
T *	add (const Context &context, std::unique_ptr< T > symbol)
template<typename T >
T *	addOrDie (std::unique_ptr< T > symbol)
void	injectWithoutOwnership (Symbol *symbol)
template<typename T >
T *	inject (std::unique_ptr< T > symbol)
template<typename T >
T *	takeOwnershipOfSymbol (std::unique_ptr< T > symbol)
const Type *	addArrayDimension (const Context &context, const Type *type, int arraySize)
template<typename Fn >
void	foreach (Fn &&fn) const
bool	wouldShadowSymbolsFrom (const SymbolTable *other) const
size_t	count () const
bool	isBuiltin () const
const std::string *	takeOwnershipOfString (std::string n)
void	markModuleBoundary ()

Public Attributes
SymbolTable *	fParent = nullptr
std::vector< std::unique_ptr< Symbol > >	fOwnedSymbols

Detailed Description

Maps identifiers to symbols.

Definition at line 35 of file SkSLSymbolTable.h.

Constructor & Destructor Documentation

SymbolTable() [1/2]

SkSL::SymbolTable::SymbolTable ( bool  builtin )

inlineexplicit

Definition at line 37 of file SkSLSymbolTable.h.

            : fBuiltin(builtin) {}

SymbolTable() [2/2]

SkSL::SymbolTable::SymbolTable ( SymbolTable *  parent, bool  builtin  )

inlineexplicit

Definition at line 40 of file SkSLSymbolTable.h.

            : fParent(parent)
            , fBuiltin(builtin) {}

Member Function Documentation

add()

template<typename T >

T * SkSL::SymbolTable::add ( const Context &  context, std::unique_ptr< T >  symbol  )

inline

Adds a symbol to this symbol table, conferring ownership. The symbol table will always be updated to reference the new symbol. If the symbol already exists, an error will be reported.

Definition at line 121 of file SkSLSymbolTable.h.

                                                            {
        T* ptr = symbol.get();
        this->addWithoutOwnership(context, this->takeOwnershipOfSymbol(std::move(symbol)));
        return ptr;
    }

addArrayDimension()

const Type * SkSL::SymbolTable::addArrayDimension	(	const Context &	context,
		const Type *	type,
		int	arraySize
	)

Given type = float and arraySize = 5, creates the array type float[5] in the symbol table. The created array type is returned. If zero is passed, the base type is returned unchanged.

Definition at line 173 of file SkSLSymbolTable.cpp.

                                                          {
    if (arraySize == 0) {
        return type;
    }
    // If we are making an array of a builtin type, we add it as high as possible in the symbol
    // table tree (at the module boundary), to enable additional reuse of the array-type.
    if (fParent && !fAtModuleBoundary && !context.fConfig->fIsBuiltinCode && type->isBuiltin()) {
        return fParent->addArrayDimension(context, type, arraySize);
    }
    // Reuse an existing array type with this name if one already exists in our symbol table.
    std::string arrayName = type->getArrayName(arraySize);
    if (const Symbol* existingType = this->find(arrayName)) {
        return &existingType->as<Type>();
    }
    // Add a new array type to the symbol table.
    const std::string* arrayNamePtr = this->takeOwnershipOfString(std::move(arrayName));
    return this->add(context, Type::MakeArrayType(context, *arrayNamePtr, *type, arraySize));
}

addOrDie()

template<typename T >

T * SkSL::SymbolTable::addOrDie ( std::unique_ptr< T >  symbol )

inline

Adds a symbol to this symbol table, conferring ownership. The symbol table will always be updated to reference the new symbol. If the symbol already exists, abort.

Definition at line 132 of file SkSLSymbolTable.h.

                                         {
        T* ptr = symbol.get();
        this->addWithoutOwnershipOrDie(this->takeOwnershipOfSymbol(std::move(symbol)));
        return ptr;
    }

addWithoutOwnership()

void SkSL::SymbolTable::addWithoutOwnership	(	const Context &	context,
		Symbol *	symbol
	)

Definition at line 123 of file SkSLSymbolTable.cpp.

                                                                            {
    if (!this->addWithoutOwnership(symbol)) {
        context.fErrors->error(symbol->position(),
                               "symbol '" + std::string(symbol->name()) + "' was already defined");
    }
}

addWithoutOwnershipOrDie()

void SkSL::SymbolTable::addWithoutOwnershipOrDie

(

Symbol *

symbol

)

Adds a symbol to this symbol table, without conferring ownership. The caller is responsible for keeping the Symbol alive throughout the lifetime of the program/module.

Definition at line 130 of file SkSLSymbolTable.cpp.

                                                         {
    if (!this->addWithoutOwnership(symbol)) {
        SK_ABORT("symbol '%.*s' was already defined",
                 (int)symbol->name().size(), symbol->name().data());
    }
}

count()

size_t SkSL::SymbolTable::count ( ) const

inline

Definition at line 183 of file SkSLSymbolTable.h.

                         {
        return fSymbols.count();
    }

find()

const Symbol * SkSL::SymbolTable::find ( std::string_view  name ) const

inline

Looks up the requested symbol and returns a const pointer.

Definition at line 54 of file SkSLSymbolTable.h.

                                                  {
        return this->lookup(MakeSymbolKey(name));
    }

findBuiltinSymbol()

const Symbol * SkSL::SymbolTable::findBuiltinSymbol

(

std::string_view

name

)

const

Looks up the requested symbol, only searching the built-in symbol tables. Always const.

Definition at line 38 of file SkSLSymbolTable.cpp.

                                                                      {
    if (!this->isBuiltin()) {
        return fParent ? fParent->findBuiltinSymbol(name) : nullptr;
    }
    return this->find(name);
}

findMutable()

Symbol * SkSL::SymbolTable::findMutable ( std::string_view  name ) const

inline

Looks up the requested symbol and returns a mutable pointer. Use caution–mutating a symbol will have program-wide impact, and built-in symbol tables must never be mutated.

Definition at line 67 of file SkSLSymbolTable.h.

                                                   {
        return this->lookup(MakeSymbolKey(name));
    }

foreach()

template<typename Fn >

void SkSL::SymbolTable::foreach ( Fn &&  fn ) const

inline

Definition at line 174 of file SkSLSymbolTable.h.

                                {
        fSymbols.foreach(
                [&fn](const SymbolKey& key, const Symbol* symbol) { fn(key.fName, symbol); });
    }

inject()

template<typename T >

T * SkSL::SymbolTable::inject ( std::unique_ptr< T >  symbol )

inline

Forces a symbol into this symbol table, conferring ownership. Replaces any existing symbol with the same name, if one exists.

Definition at line 149 of file SkSLSymbolTable.h.

                                       {
        T* ptr = symbol.get();
        this->injectWithoutOwnership(this->takeOwnershipOfSymbol(std::move(symbol)));
        return ptr;
    }

injectWithoutOwnership()

void SkSL::SymbolTable::injectWithoutOwnership

(

Symbol *

symbol

)

Forces a symbol into this symbol table, without conferring ownership. Replaces any existing symbol with the same name, if one exists.

Definition at line 168 of file SkSLSymbolTable.cpp.

                                                       {
    auto key = MakeSymbolKey(symbol->name());
    fSymbols[key] = symbol;
}

insertNewParent()

std::unique_ptr< SymbolTable > SkSL::SymbolTable::insertNewParent

(

)

Creates a new, empty SymbolTable between this SymbolTable and its current parent. The new symbol table is returned, and is also accessible as this->fParent. The original parent is accessible as this->fParent->fParent.

Definition at line 20 of file SkSLSymbolTable.cpp.

                                                        {
    auto newTable = std::make_unique<SymbolTable>(fParent, fBuiltin);
    fParent = newTable.get();
    return newTable;
}

instantiateSymbolRef()

std::unique_ptr< Expression > SkSL::SymbolTable::instantiateSymbolRef	(	const Context &	context,
		std::string_view	name,
		Position	pos
	)

Looks up the requested symbol and instantiates an Expression reference to it; will return a VariableReference, TypeReference, FunctionReference, FieldAccess, or nullptr.

Definition at line 194 of file SkSLSymbolTable.cpp.

                                                                            {
    if (const Symbol* symbol = this->find(name)) {
        return symbol->instantiate(context, pos);
    }
    context.fErrors->error(pos, "unknown identifier '" + std::string(name) + "'");
    return nullptr;
}

isBuiltin()

bool SkSL::SymbolTable::isBuiltin ( ) const

inline

Returns true if this is a built-in SymbolTable.

Definition at line 188 of file SkSLSymbolTable.h.

                           {
        return fBuiltin;
    }

isBuiltinType()

bool SkSL::SymbolTable::isBuiltinType

(

std::string_view

name

)

const

Returns true if the name refers to a builtin type.

Definition at line 31 of file SkSLSymbolTable.cpp.

                                                         {
    if (!this->isBuiltin()) {
        return fParent && fParent->isBuiltinType(name);
    }
    return this->isType(name);
}

isType()

bool SkSL::SymbolTable::isType

(

std::string_view

name

)

const

Returns true if the name refers to a type (user or built-in) in the current symbol table.

Definition at line 26 of file SkSLSymbolTable.cpp.

                                                  {
    const Symbol* symbol = this->find(name);
    return symbol && symbol->is<Type>();
}

markModuleBoundary()

void SkSL::SymbolTable::markModuleBoundary ( )

inline

Indicates that this symbol table's parent is in a different module than this one.

Definition at line 197 of file SkSLSymbolTable.h.

                              {
        fAtModuleBoundary = true;
    }

moveSymbolTo()

void SkSL::SymbolTable::moveSymbolTo	(	SymbolTable *	otherTable,
		Symbol *	sym,
		const Context &	context
	)

Moves a symbol from this symbol table to another one. If this symbol table had ownership of the symbol, the ownership will be transferred as well. (If the symbol does not actually exist in this table at all, it will still be added to the other table.)

Definition at line 109 of file SkSLSymbolTable.cpp.

                                                                                           {
    if (std::unique_ptr<Symbol> ownedSymbol = this->removeSymbol(sym)) {
        otherTable->add(context, std::move(ownedSymbol));
    } else {
        otherTable->addWithoutOwnership(context, sym);
    }
}

removeSymbol()

std::unique_ptr< Symbol > SkSL::SymbolTable::removeSymbol

(

const Symbol *

symbol

)

Removes a symbol from the symbol table. If this symbol table had ownership of the symbol, the symbol is returned (and can be deleted or reinserted as desired); if not, null is returned. In either event, the name will no longer correspond to the symbol.

Definition at line 93 of file SkSLSymbolTable.cpp.

                                                                    {
    // Remove the symbol from our symbol lookup table.
    if (fSymbols.removeIfExists(MakeSymbolKey(symbol->name()))) {
        // Transfer ownership of the symbol if we own it. (This will leave a nullptr behind in the
        // `fOwnedSymbols` list, which should be harmless.)
        for (std::unique_ptr<Symbol>& owned : fOwnedSymbols) {
            if (symbol == owned.get()) {
                return std::move(owned);
            }
        }
    }
 
    // We don't own the symbol after all.
    return nullptr;
}

renameSymbol()

void SkSL::SymbolTable::renameSymbol	(	const Context &	context,
		Symbol *	symbol,
		std::string_view	newName
	)

Assigns a new name to the passed-in symbol. The old name will continue to exist in the symbol table and point to the symbol.

Definition at line 78 of file SkSLSymbolTable.cpp.

                                                                                             {
    if (symbol->is<FunctionDeclaration>()) {
        // This is a function declaration, so we need to rename the entire overload set.
        for (FunctionDeclaration* fn = &symbol->as<FunctionDeclaration>(); fn != nullptr;
             fn = fn->mutableNextOverload()) {
            fn->setName(newName);
        }
    } else {
        // Other types of symbols don't allow multiple symbols with the same name.
        symbol->setName(newName);
    }
 
    this->addWithoutOwnership(context, symbol);
}

takeOwnershipOfString()

const std::string * SkSL::SymbolTable::takeOwnershipOfString

(

std::string

n

)

Definition at line 117 of file SkSLSymbolTable.cpp.

                                                                 {
    fOwnedStrings.push_front(std::move(str));
    // Because fOwnedStrings is a linked list, pointers to elements are stable.
    return &fOwnedStrings.front();
}

takeOwnershipOfSymbol()

template<typename T >

T * SkSL::SymbolTable::takeOwnershipOfSymbol ( std::unique_ptr< T >  symbol )

inline

Confers ownership of a symbol without adding its name to the lookup table.

Definition at line 159 of file SkSLSymbolTable.h.

                                                      {
        T* ptr = symbol.get();
        fOwnedSymbols.push_back(std::move(symbol));
        return ptr;
    }

wouldShadowSymbolsFrom()

bool SkSL::SymbolTable::wouldShadowSymbolsFrom

(

const SymbolTable *

other

)

const

Definition at line 45 of file SkSLSymbolTable.cpp.

                                                                       {
    // We are checking two hash maps for overlap; we always iterate over the smaller one to minimize
    // the total number of checks.
    const SymbolTable* self = this;
    if (self->count() > other->count()) {
        std::swap(self, other);
    }
 
    bool foundShadow = false;
 
    self->fSymbols.foreach([&](const SymbolKey& key, const Symbol* symbol) {
        if (foundShadow) {
            // We've already found a shadowed symbol; stop searching.
            return;
        }
        if (other->fSymbols.find(key) != nullptr) {
            foundShadow = true;
        }
    });
 
    return foundShadow;
}

Member Data Documentation

fOwnedSymbols

std::vector<std::unique_ptr<Symbol> > SkSL::SymbolTable::fOwnedSymbols

Definition at line 203 of file SkSLSymbolTable.h.

fParent

SymbolTable* SkSL::SymbolTable::fParent = nullptr

Definition at line 201 of file SkSLSymbolTable.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/sksl/ir/SkSLSymbolTable.h
• third_party/skia/src/sksl/ir/SkSLSymbolTable.cpp