SkSL::Block Class Reference

#include <SkSLBlock.h>

Inheritance diagram for SkSL::Block:

Public Types
enum class	Kind { kUnbracedBlock , kBracedScope , kCompoundStatement }
Public Types inherited from SkSL::Statement
using	Kind = StatementKind

Public Member Functions
	Block (Position pos, StatementArray statements, Kind kind=Kind::kBracedScope, std::unique_ptr< SymbolTable > symbols=nullptr)
const StatementArray &	children () const
StatementArray &	children ()
bool	isScope () const
Kind	blockKind () const
void	setBlockKind (Kind kind)
SymbolTable *	symbolTable () const
bool	isEmpty () const override
std::string	description () const override
Public Member Functions inherited from SkSL::Statement
	Statement (Position pos, Kind kind)
Kind	kind () const
virtual bool	isEmpty () const
Public Member Functions inherited from SkSL::IRNode
virtual	~IRNode ()
virtual std::string	description () const =0
	IRNode (const IRNode &)=delete
IRNode &	operator= (const IRNode &)=delete
Position	position () const
void	setPosition (Position p)
template<typename T >
bool	is () const
template<typename T >
const T &	as () const
template<typename T >
T &	as ()

Static Public Member Functions
static std::unique_ptr< Statement >	Make (Position pos, StatementArray statements, Kind kind=Kind::kBracedScope, std::unique_ptr< SymbolTable > symbols=nullptr)
static std::unique_ptr< Statement >	MakeCompoundStatement (std::unique_ptr< Statement > existing, std::unique_ptr< Statement > additional)
static std::unique_ptr< Block >	MakeBlock (Position pos, StatementArray statements, Kind kind=Kind::kBracedScope, std::unique_ptr< SymbolTable > symbols=nullptr)
Static Public Member Functions inherited from SkSL::Poolable
static void *	operator new (const size_t size)
static void	operator delete (void *ptr)

Static Public Attributes
static constexpr Kind	kIRNodeKind = Kind::kBlock

Additional Inherited Members
Public Attributes inherited from SkSL::IRNode
Position	fPosition
Protected Member Functions inherited from SkSL::IRNode
	IRNode (Position position, int kind)
Protected Attributes inherited from SkSL::IRNode
int	fKind

Detailed Description

A block of multiple statements functioning as a single statement.

Definition at line 26 of file SkSLBlock.h.

Member Enumeration Documentation

Kind

enum class SkSL::Block::Kind

strong

Enumerator
kUnbracedBlock
kBracedScope
kCompoundStatement

Definition at line 32 of file SkSLBlock.h.

                    {
        kUnbracedBlock,      // Represents a group of statements without curly braces.
        kBracedScope,        // Represents a language-level Block, with curly braces.
        kCompoundStatement,  // A block which conceptually represents a single statement, such as
                             // `int a, b;`. (SkSL represents this internally as two statements:
                             // `int a; int b;`) Allowed to optimize away to its interior Statement.
                             // Treated as a single statement by the debugger.
    };

Constructor & Destructor Documentation

Block()

SkSL::Block::Block ( Position  pos, StatementArray  statements, Kind  kind = Kind::kBracedScope, std::unique_ptr< SymbolTable >  symbols = nullptr  )

inline

Definition at line 41 of file SkSLBlock.h.

            : INHERITED(pos, kIRNodeKind)
            , fSymbolTable(std::move(symbols))
            , fChildren(std::move(statements))
            , fBlockKind(kind) {}

Member Function Documentation

blockKind()

Kind SkSL::Block::blockKind ( ) const

inline

Definition at line 83 of file SkSLBlock.h.

                           {
        return fBlockKind;
    }

children() [1/2]

StatementArray & SkSL::Block::children ( )

inline

Definition at line 75 of file SkSLBlock.h.

                               {
        return fChildren;
    }

children() [2/2]

const StatementArray & SkSL::Block::children ( ) const

inline

Definition at line 71 of file SkSLBlock.h.

                                           {
        return fChildren;
    }

description()

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

overridevirtual

Implements SkSL::IRNode.

Definition at line 97 of file SkSLBlock.cpp.

                                   {
    std::string result;
 
    // Write scope markers if this block is a scope, or if the block is empty (since we need to emit
    // something here to make the code valid).
    bool isScope = this->isScope() || this->isEmpty();
    if (isScope) {
        result += "{";
    }
    for (const std::unique_ptr<Statement>& stmt : this->children()) {
        result += "\n";
        result += stmt->description();
    }
    result += isScope ? "\n}\n" : "\n";
    return result;
}

isEmpty()

bool SkSL::Block::isEmpty ( ) const

inlineoverridevirtual

Reimplemented from SkSL::Statement.

Definition at line 95 of file SkSLBlock.h.

                                  {
        for (const std::unique_ptr<Statement>& stmt : this->children()) {
            if (!stmt->isEmpty()) {
                return false;
            }
        }
        return true;
    }

isScope()

bool SkSL::Block::isScope ( ) const

inline

Definition at line 79 of file SkSLBlock.h.

                         {
        return fBlockKind == Kind::kBracedScope;
    }

Make()

std::unique_ptr< Statement > SkSL::Block::Make ( Position  pos, StatementArray  statements, Kind  kind = Kind::kBracedScope, std::unique_ptr< SymbolTable >  symbols = nullptr  )

static

Definition at line 14 of file SkSLBlock.cpp.

                                                                           {
    // We can't simplify away braces or populated symbol tables.
    if (kind == Kind::kBracedScope || (symbols && symbols->count())) {
        return std::make_unique<Block>(pos, std::move(statements), kind, std::move(symbols));
    }
 
    // If the Block is completely empty, synthesize a Nop.
    if (statements.empty()) {
        return Nop::Make();
    }
 
    if (statements.size() > 1) {
        // The statement array contains multiple statements, but some of those might be no-ops.
        // If the statement array only contains one real statement, we can return that directly and
        // avoid creating an additional Block node.
        std::unique_ptr<Statement>* foundStatement = nullptr;
        for (std::unique_ptr<Statement>& stmt : statements) {
            if (!stmt->isEmpty()) {
                if (!foundStatement) {
                    // We found a single non-empty statement. Remember it and keep looking.
                    foundStatement = &stmt;
                    continue;
                }
                // We found more than one non-empty statement. We actually do need a Block.
                return std::make_unique<Block>(pos, std::move(statements), kind,
                                               /*symbols=*/nullptr);
            }
        }
 
        // The array wrapped one valid Statement. Avoid allocating a Block by returning it directly.
        if (foundStatement) {
            return std::move(*foundStatement);
        }
 
        // The statement array contained nothing but empty statements!
        // In this case, we don't actually need to allocate a Block.
        // We can just return one of those empty statements. Fall through to...
    }
 
    return std::move(statements.front());
}

MakeBlock()

std::unique_ptr< Block > SkSL::Block::MakeBlock ( Position  pos, StatementArray  statements, Kind  kind = Kind::kBracedScope, std::unique_ptr< SymbolTable >  symbols = nullptr  )

static

Definition at line 59 of file SkSLBlock.cpp.

                                                                            {
    // Nothing to optimize here--eliminating empty statements doesn't actually improve the generated
    // code, and we promise to return a Block.
    return std::make_unique<Block>(pos, std::move(statements), kind, std::move(symbols));
}

MakeCompoundStatement()

std::unique_ptr< Statement > SkSL::Block::MakeCompoundStatement ( std::unique_ptr< Statement >  existing, std::unique_ptr< Statement >  additional  )

static

Definition at line 68 of file SkSLBlock.cpp.

                                                                                             {
    // If either of the two Statements is empty, return the other.
    if (!existing || existing->isEmpty()) {
        return additional;
    }
    if (!additional || additional->isEmpty()) {
        return existing;
    }
 
    // If the existing statement is a compound-statement Block, append the additional statement.
    if (existing->is<Block>()) {
        SkSL::Block& block = existing->as<Block>();
        if (block.blockKind() == Block::Kind::kCompoundStatement) {
            block.children().push_back(std::move(additional));
            return existing;
        }
    }
 
    // The existing statement was not a compound-statement Block; create one, and put both
    // statements inside of it.
    Position pos = existing->fPosition.rangeThrough(additional->fPosition);
    StatementArray stmts;
    stmts.reserve_exact(2);
    stmts.push_back(std::move(existing));
    stmts.push_back(std::move(additional));
    return Block::Make(pos, std::move(stmts), Block::Kind::kCompoundStatement);
}

setBlockKind()

void SkSL::Block::setBlockKind ( Kind  kind )

inline

Definition at line 87 of file SkSLBlock.h.

                                 {
        fBlockKind = kind;
    }

symbolTable()

SymbolTable * SkSL::Block::symbolTable ( ) const

inline

Definition at line 91 of file SkSLBlock.h.

                                     {
        return fSymbolTable.get();
    }

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::Block::kIRNodeKind = Kind::kBlock

inlinestaticconstexpr

Definition at line 28 of file SkSLBlock.h.

---

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

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