SkSL::SwitchStatement Class Reference

#include <SkSLSwitchStatement.h>

Inheritance diagram for SkSL::SwitchStatement:

Public Member Functions
	SwitchStatement (Position pos, std::unique_ptr< Expression > value, std::unique_ptr< Statement > caseBlock)
std::unique_ptr< Expression > &	value ()
const std::unique_ptr< Expression > &	value () const
std::unique_ptr< Statement > &	caseBlock ()
const std::unique_ptr< Statement > &	caseBlock () const
StatementArray &	cases ()
const StatementArray &	cases () const
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 ()
	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 >	Convert (const Context &context, Position pos, std::unique_ptr< Expression > value, ExpressionArray caseValues, StatementArray caseStatements, std::unique_ptr< SymbolTable > symbolTable)
static std::unique_ptr< Statement >	Make (const Context &context, Position pos, std::unique_ptr< Expression > value, std::unique_ptr< Statement > caseBlock)
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::kSwitch

Additional Inherited Members
Public Types inherited from SkSL::Statement
using	Kind = StatementKind
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 'switch' statement.

Definition at line 30 of file SkSLSwitchStatement.h.

Constructor & Destructor Documentation

SwitchStatement()

SkSL::SwitchStatement::SwitchStatement ( Position  pos, std::unique_ptr< Expression >  value, std::unique_ptr< Statement >  caseBlock  )

inline

Definition at line 34 of file SkSLSwitchStatement.h.

            : INHERITED(pos, kIRNodeKind)
            , fValue(std::move(value))
            , fCaseBlock(std::move(caseBlock)) {}

Member Function Documentation

caseBlock() [1/2]

std::unique_ptr< Statement > & SkSL::SwitchStatement::caseBlock ( )

inline

Definition at line 66 of file SkSLSwitchStatement.h.

                                          {
        return fCaseBlock;
    }

caseBlock() [2/2]

const std::unique_ptr< Statement > & SkSL::SwitchStatement::caseBlock ( ) const

inline

Definition at line 70 of file SkSLSwitchStatement.h.

                                                      {
        return fCaseBlock;
    }

cases() [1/2]

StatementArray & SkSL::SwitchStatement::cases ( )

inline

Definition at line 74 of file SkSLSwitchStatement.h.

                            {
        return fCaseBlock->as<Block>().children();
    }

cases() [2/2]

const StatementArray & SkSL::SwitchStatement::cases ( ) const

inline

Definition at line 78 of file SkSLSwitchStatement.h.

                                        {
        return fCaseBlock->as<Block>().children();
    }

Convert()

std::unique_ptr< Statement > SkSL::SwitchStatement::Convert ( const Context &  context, Position  pos, std::unique_ptr< Expression >  value, ExpressionArray  caseValues, StatementArray  caseStatements, std::unique_ptr< SymbolTable >  symbolTable  )

static

Definition at line 148 of file SkSLSwitchStatement.cpp.

                                                                                            {
    SkASSERT(caseValues.size() == caseStatements.size());
 
    value = context.fTypes.fInt->coerceExpression(std::move(value), context);
    if (!value) {
        return nullptr;
    }
 
    StatementArray cases;
    for (int i = 0; i < caseValues.size(); ++i) {
        if (caseValues[i]) {
            Position casePos = caseValues[i]->fPosition;
            // Case values must be constant integers of the same type as the switch value
            std::unique_ptr<Expression> caseValue = value->type().coerceExpression(
                    std::move(caseValues[i]), context);
            if (!caseValue) {
                return nullptr;
            }
            SKSL_INT intValue;
            if (!ConstantFolder::GetConstantInt(*caseValue, &intValue)) {
                context.fErrors->error(casePos, "case value must be a constant integer");
                return nullptr;
            }
            cases.push_back(SwitchCase::Make(casePos, intValue, std::move(caseStatements[i])));
        } else {
            cases.push_back(SwitchCase::MakeDefault(pos, std::move(caseStatements[i])));
        }
    }
 
    // Detect duplicate `case` labels and report an error.
    // (Using forward_list here to optimize for the common case of no results.)
    std::forward_list<const SwitchCase*> duplicateCases = find_duplicate_case_values(cases);
    if (!duplicateCases.empty()) {
        duplicateCases.reverse();
        for (const SwitchCase* sc : duplicateCases) {
            if (sc->isDefault()) {
                context.fErrors->error(sc->fPosition, "duplicate default case");
            } else {
                context.fErrors->error(sc->fPosition, "duplicate case value '" +
                                                      std::to_string(sc->value()) + "'");
            }
        }
        return nullptr;
    }
 
    return SwitchStatement::Make(context,
                                 pos,
                                 std::move(value),
                                 Block::MakeBlock(pos,
                                                  std::move(cases),
                                                  Block::Kind::kBracedScope,
                                                  std::move(symbolTable)));
}

description()

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

overridevirtual

Implements SkSL::IRNode.

Definition at line 37 of file SkSLSwitchStatement.cpp.

                                             {
    return "switch (" + this->value()->description() + ") " + this->caseBlock()->description();
}

Make()

std::unique_ptr< Statement > SkSL::SwitchStatement::Make ( const Context &  context, Position  pos, std::unique_ptr< Expression >  value, std::unique_ptr< Statement >  caseBlock  )

static

Definition at line 207 of file SkSLSwitchStatement.cpp.

                                                                                     {
    // Confirm that every statement in `cases` is a SwitchCase.
    const StatementArray& cases = caseBlock->as<Block>().children();
    SkASSERT(std::all_of(cases.begin(), cases.end(), [&](const std::unique_ptr<Statement>& stmt) {
        return stmt->is<SwitchCase>();
    }));
 
    // Confirm that every switch-case value is unique.
    SkASSERT(find_duplicate_case_values(cases).empty());
 
    // Flatten switch statements if we're optimizing, and the value is known
    if (context.fConfig->fSettings.fOptimize) {
        SKSL_INT switchValue;
        if (ConstantFolder::GetConstantInt(*value, &switchValue)) {
            SwitchCase* defaultCase = nullptr;
            SwitchCase* matchingCase = nullptr;
            for (const std::unique_ptr<Statement>& stmt : cases) {
                SwitchCase& sc = stmt->as<SwitchCase>();
                if (sc.isDefault()) {
                    defaultCase = &sc;
                    continue;
                }
 
                if (sc.value() == switchValue) {
                    matchingCase = &sc;
                    break;
                }
            }
 
            if (!matchingCase) {
                // No case value matches the switch value.
                if (!defaultCase) {
                    // No default switch-case exists; the switch had no effect.
                    // We can eliminate the entire switch!
                    return Nop::Make();
                }
                // We had a default case; that's what we matched with.
                matchingCase = defaultCase;
            }
 
            // Strip down our case block to contain only the matching case, if we can.
            if (block_for_case(caseBlock.get(), matchingCase)) {
                return caseBlock;
            }
        }
    }
 
    // The switch couldn't be optimized away; emit it normally.
    auto stmt = std::make_unique<SwitchStatement>(pos, std::move(value), std::move(caseBlock));
 
    // If a switch-case has variable declarations at its top level, we want to create a scoped block
    // around the switch, then move the variable declarations out of the switch body and into the
    // outer scope. This prevents scoping issues in backends which don't offer a native switch.
    // (skia:14375)
    return Transform::HoistSwitchVarDeclarationsAtTopLevel(context, std::move(stmt));
}

value() [1/2]

std::unique_ptr< Expression > & SkSL::SwitchStatement::value ( )

inline

Definition at line 58 of file SkSLSwitchStatement.h.

                                       {
        return fValue;
    }

value() [2/2]

const std::unique_ptr< Expression > & SkSL::SwitchStatement::value ( ) const

inline

Definition at line 62 of file SkSLSwitchStatement.h.

                                                   {
        return fValue;
    }

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::SwitchStatement::kIRNodeKind = Kind::kSwitch

inlinestaticconstexpr

Definition at line 32 of file SkSLSwitchStatement.h.

---

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

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