#include <SkSLProgram.h>

Classes
class	ElementsCollection

Public Types
using	Interface = ProgramInterface

Public Member Functions
	Program (std::unique_ptr< std::string > source, std::unique_ptr< ProgramConfig > config, std::shared_ptr< Context > context, std::vector< std::unique_ptr< ProgramElement > > elements, std::unique_ptr< SymbolTable > symbols, std::unique_ptr< Pool > pool)

	~Program ()

ElementsCollection	elements () const

const FunctionDeclaration *	getFunction (const char *functionName) const

std::string	description () const

const ProgramUsage *	usage () const

Public Attributes
std::unique_ptr< std::string >	fSource

std::unique_ptr< ProgramConfig >	fConfig

std::shared_ptr< Context >	fContext

std::unique_ptr< ProgramUsage >	fUsage

std::unique_ptr< SymbolTable >	fSymbols

std::unique_ptr< Pool >	fPool

std::vector< std::unique_ptr< ProgramElement > >	fOwnedElements

std::vector< const ProgramElement * >	fSharedElements

ProgramInterface	fInterface

Detailed Description

Represents a fully-digested program, ready for code generation.

Definition at line 65 of file SkSLProgram.h.

Member Typedef Documentation

◆ Interface

using SkSL::Program::Interface = ProgramInterface

Definition at line 167 of file SkSLProgram.h.

Constructor & Destructor Documentation

◆ Program()

SkSL::Program::Program	(	std::unique_ptr< std::string >	source,
		std::unique_ptr< ProgramConfig >	config,
		std::shared_ptr< Context >	context,
		std::vector< std::unique_ptr< ProgramElement > >	elements,
		std::unique_ptr< SymbolTable >	symbols,
		std::unique_ptr< Pool >	pool
	)

Definition at line 22 of file SkSLProgram.cpp.

        : fSource(std::move(source))
        , fConfig(std::move(config))
        , fContext(context)
        , fSymbols(std::move(symbols))
        , fPool(std::move(pool))
        , fOwnedElements(std::move(elements)) {
    fUsage = Analysis::GetUsage(*this);
}

◆ ~Program()

SkSL::Program::~Program ( )

Definition at line 37 of file SkSLProgram.cpp.

                  {
    // Some or all of the program elements are in the pool. To free them safely, we must attach
    // the pool before destroying any program elements. (Otherwise, we may accidentally call
    // delete on a pooled node.)
    AutoAttachPoolToThread attach(fPool.get());
 
    fOwnedElements.clear();
    fContext.reset();
    fSymbols.reset();
}

Member Function Documentation

◆ description()

std::string SkSL::Program::description ( ) const

Definition at line 48 of file SkSLProgram.cpp.

                                     {
    std::string result = fConfig->versionDescription();
    for (const ProgramElement* e : this->elements()) {
        result += e->description();
    }
    return result;
}

◆ elements()

ElementsCollection SkSL::Program::elements ( ) const

inline

Iterates over all elements in this Program, both owned and shared (builtin). The iterator's value type is const ProgramElement*, so it's clear that you must not modify anything (as you might be mutating shared data).

Definition at line 140 of file SkSLProgram.h.

140{ return ElementsCollection(*this); }

◆ getFunction()

const FunctionDeclaration * SkSL::Program::getFunction ( const char * functionName ) const

Returns a function declaration with the given name; null is returned if the function doesn't exist or has no definition. If the function might have overloads, you can use nextOverload() to search for the function with the expected parameter list.

Definition at line 56 of file SkSLProgram.cpp.

                                                                              {
    const Symbol* symbol = fSymbols->find(functionName);
    bool valid = symbol && symbol->is<FunctionDeclaration>() &&
                 symbol->as<FunctionDeclaration>().definition();
    return valid ? &symbol->as<FunctionDeclaration>() : nullptr;
}

◆ usage()

const ProgramUsage * SkSL::Program::usage ( ) const

inline

Definition at line 150 of file SkSLProgram.h.

150{ return fUsage.get(); }

Member Data Documentation

◆ fConfig

std::unique_ptr<ProgramConfig> SkSL::Program::fConfig

Definition at line 153 of file SkSLProgram.h.

◆ fContext

std::shared_ptr<Context> SkSL::Program::fContext

Definition at line 154 of file SkSLProgram.h.

◆ fInterface

ProgramInterface SkSL::Program::fInterface

Definition at line 165 of file SkSLProgram.h.

◆ fOwnedElements

std::vector<std::unique_ptr<ProgramElement> > SkSL::Program::fOwnedElements

Definition at line 161 of file SkSLProgram.h.

◆ fPool

std::unique_ptr<Pool> SkSL::Program::fPool

Definition at line 159 of file SkSLProgram.h.

◆ fSharedElements

std::vector<const ProgramElement*> SkSL::Program::fSharedElements

Definition at line 164 of file SkSLProgram.h.

◆ fSource

std::unique_ptr<std::string> SkSL::Program::fSource

Definition at line 152 of file SkSLProgram.h.

◆ fSymbols

std::unique_ptr<SymbolTable> SkSL::Program::fSymbols

Definition at line 158 of file SkSLProgram.h.

◆ fUsage

std::unique_ptr<ProgramUsage> SkSL::Program::fUsage

Definition at line 155 of file SkSLProgram.h.

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

third_party/skia/src/sksl/ir/SkSLProgram.h
third_party/skia/src/sksl/ir/SkSLProgram.cpp

Classes

Public Types

Public Member Functions

Public Attributes