SkSL::BinaryExpression Class Reference

#include <SkSLBinaryExpression.h>

Inheritance diagram for SkSL::BinaryExpression:

Public Member Functions
	BinaryExpression (Position pos, std::unique_ptr< Expression > left, Operator op, std::unique_ptr< Expression > right, const Type *type)
std::unique_ptr< Expression > &	left ()
const std::unique_ptr< Expression > &	left () const
std::unique_ptr< Expression > &	right ()
const std::unique_ptr< Expression > &	right () const
Operator	getOperator () const
std::unique_ptr< Expression >	clone (Position pos) const override
std::string	description (OperatorPrecedence parentPrecedence) const override
VariableReference *	isAssignmentIntoVariable ()
Public Member Functions inherited from SkSL::Expression
	Expression (Position pos, Kind kind, const Type *type)
Kind	kind () const
const Type &	type () const
bool	isAnyConstructor () const
bool	isIntLiteral () const
bool	isFloatLiteral () const
bool	isBoolLiteral () const
AnyConstructor &	asAnyConstructor ()
const AnyConstructor &	asAnyConstructor () const
bool	isIncomplete (const Context &context) const
virtual ComparisonResult	compareConstant (const Expression &other) const
CoercionCost	coercionCost (const Type &target) const
virtual bool	supportsConstantValues () const
virtual std::optional< double >	getConstantValue (int n) const
virtual std::unique_ptr< Expression >	clone (Position pos) const =0
std::unique_ptr< Expression >	clone () const
std::string	description () const final
virtual std::string	description (OperatorPrecedence parentPrecedence) const =0
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< Expression >	Convert (const Context &context, Position pos, std::unique_ptr< Expression > left, Operator op, std::unique_ptr< Expression > right)
static std::unique_ptr< Expression >	Make (const Context &context, Position pos, std::unique_ptr< Expression > left, Operator op, std::unique_ptr< Expression > right)
static std::unique_ptr< Expression >	Make (const Context &context, Position pos, std::unique_ptr< Expression > left, Operator op, std::unique_ptr< Expression > right, const Type *resultType)
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::kBinary

Additional Inherited Members
Public Types inherited from SkSL::Expression
enum class	ComparisonResult { kUnknown = -1 , kNotEqual , kEqual }
using	Kind = ExpressionKind
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 binary operation.

Definition at line 30 of file SkSLBinaryExpression.h.

Constructor & Destructor Documentation

BinaryExpression()

SkSL::BinaryExpression::BinaryExpression ( Position  pos, std::unique_ptr< Expression >  left, Operator  op, std::unique_ptr< Expression >  right, const Type *  type  )

inline

Definition at line 34 of file SkSLBinaryExpression.h.

        : INHERITED(pos, kIRNodeKind, type)
        , fLeft(std::move(left))
        , fOperator(op)
        , fRight(std::move(right)) {
        // If we are assigning to a VariableReference, ensure that it is set to Write or ReadWrite.
        SkASSERT(!op.isAssignment() || CheckRef(*this->left()));
    }

Member Function Documentation

clone()

std::unique_ptr< Expression > SkSL::BinaryExpression::clone ( Position  pos ) const

overridevirtual

Implements SkSL::Expression.

Definition at line 166 of file SkSLBinaryExpression.cpp.

                                                                    {
    return std::make_unique<BinaryExpression>(pos,
                                              this->left()->clone(),
                                              this->getOperator(),
                                              this->right()->clone(),
                                              &this->type());
}

Convert()

std::unique_ptr< Expression > SkSL::BinaryExpression::Convert ( const Context &  context, Position  pos, std::unique_ptr< Expression >  left, Operator  op, std::unique_ptr< Expression >  right  )

static

Definition at line 24 of file SkSLBinaryExpression.cpp.

                                                                                       {
    if (!left || !right) {
        return nullptr;
    }
    const Type* rawLeftType = (left->isIntLiteral() && right->type().isInteger())
            ? &right->type()
            : &left->type();
    const Type* rawRightType = (right->isIntLiteral() && left->type().isInteger())
            ? &left->type()
            : &right->type();
 
    bool isAssignment = op.isAssignment();
    if (isAssignment &&
        !Analysis::UpdateVariableRefKind(left.get(),
                                         op.kind() != Operator::Kind::EQ
                                                 ? VariableReference::RefKind::kReadWrite
                                                 : VariableReference::RefKind::kWrite,
                                         context.fErrors)) {
        return nullptr;
    }
 
    const Type* leftType;
    const Type* rightType;
    const Type* resultType;
    if (!op.determineBinaryType(context, *rawLeftType, *rawRightType,
                                &leftType, &rightType, &resultType)) {
        context.fErrors->error(pos, "type mismatch: '" + std::string(op.tightOperatorName()) +
                                    "' cannot operate on '" + left->type().displayName() + "', '" +
                                    right->type().displayName() + "'");
        return nullptr;
    }
 
    if (isAssignment && (leftType->componentType().isOpaque() || leftType->isOrContainsAtomic())) {
        context.fErrors->error(pos, "assignments to opaque type '" + left->type().displayName() +
                                    "' are not permitted");
        return nullptr;
    }
    if (context.fConfig->strictES2Mode() && !op.isAllowedInStrictES2Mode()) {
        context.fErrors->error(pos, "operator '" + std::string(op.tightOperatorName()) +
                                    "' is not allowed");
        return nullptr;
    }
    if (context.fConfig->strictES2Mode() || op.kind() == OperatorKind::COMMA) {
        // Most operators are already rejected on arrays, but GLSL ES 1.0 is very explicit that the
        // *only* operator allowed on arrays is subscripting (and the rules against assignment,
        // comparison, and even sequence apply to structs containing arrays as well).
        // WebGL2 also restricts the usage of the sequence operator with arrays (section 5.26,
        // "Disallowed variants of GLSL ES 3.00 operators"). Since there is very little practical
        // application for sequenced array expressions, we disallow it in SkSL.
        const Expression* arrayExpr =  leftType->isOrContainsArray() ? left.get() :
                                      rightType->isOrContainsArray() ? right.get() :
                                                                       nullptr;
        if (arrayExpr) {
            context.fErrors->error(arrayExpr->position(),
                                   "operator '" + std::string(op.tightOperatorName()) +
                                   "' can not operate on arrays (or structs containing arrays)");
            return nullptr;
        }
    }
 
    left = leftType->coerceExpression(std::move(left), context);
    right = rightType->coerceExpression(std::move(right), context);
    if (!left || !right) {
        return nullptr;
    }
 
    return BinaryExpression::Make(context, pos, std::move(left), op, std::move(right), resultType);
}

description()

std::string SkSL::BinaryExpression::description ( OperatorPrecedence  parentPrecedence ) const

overridevirtual

Implements SkSL::Expression.

Definition at line 174 of file SkSLBinaryExpression.cpp.

                                                                                 {
    OperatorPrecedence operatorPrecedence = this->getOperator().getBinaryPrecedence();
    bool needsParens = (operatorPrecedence >= parentPrecedence);
    return std::string(needsParens ? "(" : "") +
           this->left()->description(operatorPrecedence) +
           this->getOperator().operatorName() +
           this->right()->description(operatorPrecedence) +
           std::string(needsParens ? ")" : "");
}

getOperator()

Operator SkSL::BinaryExpression::getOperator ( ) const

inline

Definition at line 85 of file SkSLBinaryExpression.h.

                                 {
        return fOperator;
    }

isAssignmentIntoVariable()

VariableReference * SkSL::BinaryExpression::isAssignmentIntoVariable

(

)

If the expression is an assignment like a = 1 or a += sin(b), returns the VariableReference that will be written to. For other types of expressions, returns null. Complex expressions that contain inner assignments, like (a = b) * 2, will return null.

Definition at line 184 of file SkSLBinaryExpression.cpp.

                                                              {
    if (this->getOperator().isAssignment()) {
        Analysis::AssignmentInfo assignmentInfo;
        if (Analysis::IsAssignable(*this->left(), &assignmentInfo, /*errors=*/nullptr)) {
            return assignmentInfo.fAssignedVar;
        }
    }
    return nullptr;
}

left() [1/2]

std::unique_ptr< Expression > & SkSL::BinaryExpression::left ( )

inline

Definition at line 69 of file SkSLBinaryExpression.h.

                                      {
        return fLeft;
    }

left() [2/2]

const std::unique_ptr< Expression > & SkSL::BinaryExpression::left ( ) const

inline

Definition at line 73 of file SkSLBinaryExpression.h.

                                                  {
        return fLeft;
    }

Make() [1/2]

std::unique_ptr< Expression > SkSL::BinaryExpression::Make ( const Context &  context, Position  pos, std::unique_ptr< Expression >  left, Operator  op, std::unique_ptr< Expression >  right  )

static

Definition at line 97 of file SkSLBinaryExpression.cpp.

                                                                                    {
    // Determine the result type of the binary expression.
    const Type* leftType;
    const Type* rightType;
    const Type* resultType;
    SkAssertResult(op.determineBinaryType(context, left->type(), right->type(),
                                          &leftType, &rightType, &resultType));
 
    return BinaryExpression::Make(context, pos, std::move(left), op, std::move(right), resultType);
}

Make() [2/2]

std::unique_ptr< Expression > SkSL::BinaryExpression::Make ( const Context &  context, Position  pos, std::unique_ptr< Expression >  left, Operator  op, std::unique_ptr< Expression >  right, const Type *  resultType  )

static

Definition at line 112 of file SkSLBinaryExpression.cpp.

                                                                           {
    // We should have detected non-ES2 compliant behavior in Convert.
    SkASSERT(!context.fConfig->strictES2Mode() || op.isAllowedInStrictES2Mode());
    SkASSERT(!context.fConfig->strictES2Mode() || !left->type().isOrContainsArray());
 
    // We should have detected non-assignable assignment expressions in Convert.
    SkASSERT(!op.isAssignment() || Analysis::IsAssignable(*left));
    SkASSERT(!op.isAssignment() || !left->type().componentType().isOpaque());
 
    // For simple assignments, detect and report out-of-range literal values.
    if (op.kind() == Operator::Kind::EQ) {
        left->type().checkForOutOfRangeLiteral(context, *right);
    }
 
    // Perform constant-folding on the expression.
    if (std::unique_ptr<Expression> result = ConstantFolder::Simplify(context, pos, *left,
                                                                      op, *right, *resultType)) {
        return result;
    }
 
    return std::make_unique<BinaryExpression>(pos, std::move(left), op,
                                              std::move(right), resultType);
}

right() [1/2]

std::unique_ptr< Expression > & SkSL::BinaryExpression::right ( )

inline

Definition at line 77 of file SkSLBinaryExpression.h.

                                       {
        return fRight;
    }

right() [2/2]

const std::unique_ptr< Expression > & SkSL::BinaryExpression::right ( ) const

inline

Definition at line 81 of file SkSLBinaryExpression.h.

                                                   {
        return fRight;
    }

Member Data Documentation

kIRNodeKind

constexpr Kind SkSL::BinaryExpression::kIRNodeKind = Kind::kBinary

inlinestaticconstexpr

Definition at line 32 of file SkSLBinaryExpression.h.

---

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

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