SkSL::TProgramVisitor< T > Class Template Reference

#include <SkSLProgramVisitor.h>

Public Member Functions
virtual	~TProgramVisitor ()=default

Protected Member Functions
virtual bool	visitExpression (typename T::Expression &expression)
virtual bool	visitStatement (typename T::Statement &statement)
virtual bool	visitProgramElement (typename T::ProgramElement &programElement)
virtual bool	visitExpressionPtr (typename T::UniquePtrExpression &expr)=0
virtual bool	visitStatementPtr (typename T::UniquePtrStatement &stmt)=0

Detailed Description

template<typename T>
class SkSL::TProgramVisitor< T >

Utility class to visit every element, statement, and expression in an SkSL program IR. This is intended for simple analysis and accumulation, where custom visitation behavior is only needed for a limited set of expression kinds.

Subclasses should override visitExpression/visitStatement/visitProgramElement as needed and intercept elements of interest. They can then invoke the base class's function to visit all sub expressions. They can also choose not to call the base function to arrest recursion, or implement custom recursion.

The visit functions return a bool that determines how the default implementation recurses. Once any visit call returns true, the default behavior stops recursing and propagates true up the stack.

Definition at line 35 of file SkSLProgramVisitor.h.

Constructor & Destructor Documentation

~TProgramVisitor()

template<typename T >

virtual SkSL::TProgramVisitor< T >::~TProgramVisitor ( )

virtualdefault

Member Function Documentation

visitExpression()

template<typename T >

bool SkSL::TProgramVisitor< T >::visitExpression ( typename T::Expression &  expression )

protectedvirtual

Definition at line 542 of file SkSLAnalysis.cpp.

                                                                                      {
    switch (e.kind()) {
        case Expression::Kind::kEmpty:
        case Expression::Kind::kFunctionReference:
        case Expression::Kind::kLiteral:
        case Expression::Kind::kMethodReference:
        case Expression::Kind::kPoison:
        case Expression::Kind::kSetting:
        case Expression::Kind::kTypeReference:
        case Expression::Kind::kVariableReference:
            // Leaf expressions return false
            return false;
 
        case Expression::Kind::kBinary: {
            auto& b = e.template as<BinaryExpression>();
            return (b.left() && this->visitExpressionPtr(b.left())) ||
                   (b.right() && this->visitExpressionPtr(b.right()));
        }
        case Expression::Kind::kChildCall: {
            // We don't visit the child variable itself, just the arguments
            auto& c = e.template as<ChildCall>();
            for (auto& arg : c.arguments()) {
                if (arg && this->visitExpressionPtr(arg)) { return true; }
            }
            return false;
        }
        case Expression::Kind::kConstructorArray:
        case Expression::Kind::kConstructorArrayCast:
        case Expression::Kind::kConstructorCompound:
        case Expression::Kind::kConstructorCompoundCast:
        case Expression::Kind::kConstructorDiagonalMatrix:
        case Expression::Kind::kConstructorMatrixResize:
        case Expression::Kind::kConstructorScalarCast:
        case Expression::Kind::kConstructorSplat:
        case Expression::Kind::kConstructorStruct: {
            auto& c = e.asAnyConstructor();
            for (auto& arg : c.argumentSpan()) {
                if (this->visitExpressionPtr(arg)) { return true; }
            }
            return false;
        }
        case Expression::Kind::kFieldAccess:
            return this->visitExpressionPtr(e.template as<FieldAccess>().base());
 
        case Expression::Kind::kFunctionCall: {
            auto& c = e.template as<FunctionCall>();
            for (auto& arg : c.arguments()) {
                if (arg && this->visitExpressionPtr(arg)) { return true; }
            }
            return false;
        }
        case Expression::Kind::kIndex: {
            auto& i = e.template as<IndexExpression>();
            return this->visitExpressionPtr(i.base()) || this->visitExpressionPtr(i.index());
        }
        case Expression::Kind::kPostfix:
            return this->visitExpressionPtr(e.template as<PostfixExpression>().operand());
 
        case Expression::Kind::kPrefix:
            return this->visitExpressionPtr(e.template as<PrefixExpression>().operand());
 
        case Expression::Kind::kSwizzle: {
            auto& s = e.template as<Swizzle>();
            return s.base() && this->visitExpressionPtr(s.base());
        }
 
        case Expression::Kind::kTernary: {
            auto& t = e.template as<TernaryExpression>();
            return this->visitExpressionPtr(t.test()) ||
                   (t.ifTrue() && this->visitExpressionPtr(t.ifTrue())) ||
                   (t.ifFalse() && this->visitExpressionPtr(t.ifFalse()));
        }
        default:
            SkUNREACHABLE;
    }
}

visitExpressionPtr()

template<typename T >

virtual bool SkSL::TProgramVisitor< T >::visitExpressionPtr ( typename T::UniquePtrExpression &  expr )

protectedpure virtual

visitProgramElement()

template<typename T >

bool SkSL::TProgramVisitor< T >::visitProgramElement ( typename T::ProgramElement &  programElement )

protectedvirtual

Definition at line 677 of file SkSLAnalysis.cpp.

                                                                                               {
    switch (pe.kind()) {
        case ProgramElement::Kind::kExtension:
        case ProgramElement::Kind::kFunctionPrototype:
        case ProgramElement::Kind::kInterfaceBlock:
        case ProgramElement::Kind::kModifiers:
        case ProgramElement::Kind::kStructDefinition:
            // Leaf program elements just return false by default
            return false;
 
        case ProgramElement::Kind::kFunction:
            return this->visitStatementPtr(pe.template as<FunctionDefinition>().body());
 
        case ProgramElement::Kind::kGlobalVar:
            return this->visitStatementPtr(pe.template as<GlobalVarDeclaration>().declaration());
 
        default:
            SkUNREACHABLE;
    }
}

visitStatement()

template<typename T >

bool SkSL::TProgramVisitor< T >::visitStatement ( typename T::Statement &  statement )

protectedvirtual

Definition at line 619 of file SkSLAnalysis.cpp.

                                                                                    {
    switch (s.kind()) {
        case Statement::Kind::kBreak:
        case Statement::Kind::kContinue:
        case Statement::Kind::kDiscard:
        case Statement::Kind::kNop:
            // Leaf statements just return false
            return false;
 
        case Statement::Kind::kBlock:
            for (auto& stmt : s.template as<Block>().children()) {
                if (stmt && this->visitStatementPtr(stmt)) {
                    return true;
                }
            }
            return false;
 
        case Statement::Kind::kSwitchCase: {
            auto& sc = s.template as<SwitchCase>();
            return this->visitStatementPtr(sc.statement());
        }
        case Statement::Kind::kDo: {
            auto& d = s.template as<DoStatement>();
            return this->visitExpressionPtr(d.test()) || this->visitStatementPtr(d.statement());
        }
        case Statement::Kind::kExpression:
            return this->visitExpressionPtr(s.template as<ExpressionStatement>().expression());
 
        case Statement::Kind::kFor: {
            auto& f = s.template as<ForStatement>();
            return (f.initializer() && this->visitStatementPtr(f.initializer())) ||
                   (f.test() && this->visitExpressionPtr(f.test())) ||
                   (f.next() && this->visitExpressionPtr(f.next())) ||
                   this->visitStatementPtr(f.statement());
        }
        case Statement::Kind::kIf: {
            auto& i = s.template as<IfStatement>();
            return (i.test() && this->visitExpressionPtr(i.test())) ||
                   (i.ifTrue() && this->visitStatementPtr(i.ifTrue())) ||
                   (i.ifFalse() && this->visitStatementPtr(i.ifFalse()));
        }
        case Statement::Kind::kReturn: {
            auto& r = s.template as<ReturnStatement>();
            return r.expression() && this->visitExpressionPtr(r.expression());
        }
        case Statement::Kind::kSwitch: {
            auto& sw = s.template as<SwitchStatement>();
            return this->visitExpressionPtr(sw.value()) || this->visitStatementPtr(sw.caseBlock());
        }
        case Statement::Kind::kVarDeclaration: {
            auto& v = s.template as<VarDeclaration>();
            return v.value() && this->visitExpressionPtr(v.value());
        }
        default:
            SkUNREACHABLE;
    }
}

visitStatementPtr()

template<typename T >

virtual bool SkSL::TProgramVisitor< T >::visitStatementPtr ( typename T::UniquePtrStatement &  stmt )

protectedpure virtual

---

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

• third_party/skia/src/sksl/analysis/SkSLProgramVisitor.h
• third_party/skia/src/sksl/SkSLAnalysis.cpp