SkSL::IfStatement Class Reference

#include <SkSLIfStatement.h>

Inheritance diagram for SkSL::IfStatement:

Public Member Functions
	IfStatement (Position pos, std::unique_ptr< Expression > test, std::unique_ptr< Statement > ifTrue, std::unique_ptr< Statement > ifFalse)
std::unique_ptr< Expression > &	test ()
const std::unique_ptr< Expression > &	test () const
std::unique_ptr< Statement > &	ifTrue ()
const std::unique_ptr< Statement > &	ifTrue () const
std::unique_ptr< Statement > &	ifFalse ()
const std::unique_ptr< Statement > &	ifFalse () 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 ()
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 >	Convert (const Context &context, Position pos, std::unique_ptr< Expression > test, std::unique_ptr< Statement > ifTrue, std::unique_ptr< Statement > ifFalse)
static std::unique_ptr< Statement >	Make (const Context &context, Position pos, std::unique_ptr< Expression > test, std::unique_ptr< Statement > ifTrue, std::unique_ptr< Statement > ifFalse)
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::kIf

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

An 'if' statement.

Definition at line 27 of file SkSLIfStatement.h.

Constructor & Destructor Documentation

IfStatement()

SkSL::IfStatement::IfStatement ( Position  pos, std::unique_ptr< Expression >  test, std::unique_ptr< Statement >  ifTrue, std::unique_ptr< Statement >  ifFalse  )

inline

Definition at line 31 of file SkSLIfStatement.h.

        : INHERITED(pos, kIRNodeKind)
        , fTest(std::move(test))
        , fIfTrue(std::move(ifTrue))
        , fIfFalse(std::move(ifFalse)) {}

Member Function Documentation

Convert()

std::unique_ptr< Statement > SkSL::IfStatement::Convert ( const Context &  context, Position  pos, std::unique_ptr< Expression >  test, std::unique_ptr< Statement >  ifTrue, std::unique_ptr< Statement >  ifFalse  )

static

Definition at line 32 of file SkSLIfStatement.cpp.

                                                                                  {
    test = context.fTypes.fBool->coerceExpression(std::move(test), context);
    if (!test) {
        return nullptr;
    }
    SkASSERT(ifTrue);
    if (Analysis::DetectVarDeclarationWithoutScope(*ifTrue, context.fErrors)) {
        return nullptr;
    }
    if (ifFalse && Analysis::DetectVarDeclarationWithoutScope(*ifFalse, context.fErrors)) {
        return nullptr;
    }
    return IfStatement::Make(context, pos, std::move(test), std::move(ifTrue), std::move(ifFalse));
}

description()

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

overridevirtual

Implements SkSL::IRNode.

Definition at line 23 of file SkSLIfStatement.cpp.

                                         {
    std::string result;
    result += "if (" + this->test()->description() + ") " + this->ifTrue()->description();
    if (this->ifFalse()) {
        result += " else " + this->ifFalse()->description();
    }
    return result;
}

ifFalse() [1/2]

std::unique_ptr< Statement > & SkSL::IfStatement::ifFalse ( )

inline

Definition at line 69 of file SkSLIfStatement.h.

                                        {
        return fIfFalse;
    }

ifFalse() [2/2]

const std::unique_ptr< Statement > & SkSL::IfStatement::ifFalse ( ) const

inline

Definition at line 73 of file SkSLIfStatement.h.

                                                    {
        return fIfFalse;
    }

ifTrue() [1/2]

std::unique_ptr< Statement > & SkSL::IfStatement::ifTrue ( )

inline

Definition at line 61 of file SkSLIfStatement.h.

                                       {
        return fIfTrue;
    }

ifTrue() [2/2]

const std::unique_ptr< Statement > & SkSL::IfStatement::ifTrue ( ) const

inline

Definition at line 65 of file SkSLIfStatement.h.

                                                   {
        return fIfTrue;
    }

Make()

std::unique_ptr< Statement > SkSL::IfStatement::Make ( const Context &  context, Position  pos, std::unique_ptr< Expression >  test, std::unique_ptr< Statement >  ifTrue, std::unique_ptr< Statement >  ifFalse  )

static

Definition at line 57 of file SkSLIfStatement.cpp.

                                                                               {
    SkASSERT(test->type().matches(*context.fTypes.fBool));
    SkASSERT(!Analysis::DetectVarDeclarationWithoutScope(*ifTrue));
    SkASSERT(!ifFalse || !Analysis::DetectVarDeclarationWithoutScope(*ifFalse));
 
    const bool optimize = context.fConfig->fSettings.fOptimize;
    bool trueIsEmpty = false;
    bool falseIsEmpty = false;
 
    if (optimize) {
        // If both sides are empty, the if statement can be reduced to its test expression.
        trueIsEmpty = ifTrue->isEmpty();
        falseIsEmpty = !ifFalse || ifFalse->isEmpty();
        if (trueIsEmpty && falseIsEmpty) {
            return ExpressionStatement::Make(context, std::move(test));
        }
    }
 
    if (optimize) {
        // Static Boolean values can fold down to a single branch.
        const Expression* testValue = ConstantFolder::GetConstantValueForVariable(*test);
        if (testValue->isBoolLiteral()) {
            if (testValue->as<Literal>().boolValue()) {
                return replace_empty_with_nop(std::move(ifTrue), trueIsEmpty);
            } else {
                return replace_empty_with_nop(std::move(ifFalse), falseIsEmpty);
            }
        }
    }
 
    if (optimize) {
        // Replace an empty if-true branches with Nop; eliminate empty if-false branches entirely.
        ifTrue = replace_empty_with_nop(std::move(ifTrue), trueIsEmpty);
        if (falseIsEmpty) {
            ifFalse = nullptr;
        }
    }
 
    return std::make_unique<IfStatement>(
            pos, std::move(test), std::move(ifTrue), std::move(ifFalse));
}

test() [1/2]

std::unique_ptr< Expression > & SkSL::IfStatement::test ( )

inline

Definition at line 53 of file SkSLIfStatement.h.

                                      {
        return fTest;
    }

test() [2/2]

const std::unique_ptr< Expression > & SkSL::IfStatement::test ( ) const

inline

Definition at line 57 of file SkSLIfStatement.h.

                                                  {
        return fTest;
    }

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::IfStatement::kIRNodeKind = Kind::kIf

inlinestaticconstexpr

Definition at line 29 of file SkSLIfStatement.h.

---

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

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