#include <SkSLConstructorArray.h>

Inheritance diagram for SkSL::ConstructorArray:

Public Member Functions
	ConstructorArray (Position pos, const Type &type, ExpressionArray arguments)

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

Public Member Functions inherited from SkSL::MultiArgumentConstructor
	MultiArgumentConstructor (Position pos, Kind kind, const Type *type, ExpressionArray arguments)

ExpressionArray &	arguments ()

const ExpressionArray &	arguments () const

SkSpan< std::unique_ptr< Expression > >	argumentSpan () final

SkSpan< const std::unique_ptr< Expression > >	argumentSpan () const final

Public Member Functions inherited from SkSL::AnyConstructor
	AnyConstructor (Position pos, Kind kind, const Type *type)

virtual SkSpan< std::unique_ptr< Expression > >	argumentSpan ()=0

virtual SkSpan< const std::unique_ptr< Expression > >	argumentSpan () const =0

std::string	description (OperatorPrecedence) const override

const Type &	componentType () const

bool	supportsConstantValues () const override

std::optional< double >	getConstantValue (int n) const override

ComparisonResult	compareConstant (const Expression &other) const override

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, const Type &type, ExpressionArray args)

static std::unique_ptr< Expression >	Make (const Context &context, Position pos, const Type &type, ExpressionArray args)

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::kConstructorArray

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

Represents the construction of an array type, such as "float[5](x, y, z, w, 1)".

Definition at line 28 of file SkSLConstructorArray.h.

Constructor & Destructor Documentation

◆ ConstructorArray()

SkSL::ConstructorArray::ConstructorArray	(	Position	pos,
		const Type &	type,
		ExpressionArray	arguments
	)

inline

Definition at line 32 of file SkSLConstructorArray.h.

33 : INHERITED(pos, kIRNodeKind, &type, std::move(arguments)) {}

pos

SkPoint pos

Definition: ImageShaderTest.cpp:27

SkSL::ConstructorArray::kIRNodeKind

static constexpr Kind kIRNodeKind

Definition: SkSLConstructorArray.h:30

SkSL::Expression::type

const Type & type() const

Definition: SkSLExpression.h:44

SkSL::MultiArgumentConstructor::arguments

ExpressionArray & arguments()

Definition: SkSLConstructor.h:96

Member Function Documentation

◆ clone()

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

inlineoverridevirtual

Implements SkSL::Expression.

Definition at line 48 of file SkSLConstructorArray.h.

                                                                 {
        return std::make_unique<ConstructorArray>(pos, this->type(), this->arguments().clone());
    }

◆ Convert()

std::unique_ptr< Expression > SkSL::ConstructorArray::Convert	(	const Context &	context,
		Position	pos,
		const Type &	type,
		ExpressionArray	args
	)

static

Definition at line 23 of file SkSLConstructorArray.cpp.

                                                                            {
    SkASSERTF(type.isArray() && type.columns() > 0, "%s", type.description().c_str());
 
    // ES2 doesn't support first-class array types.
    if (context.fConfig->strictES2Mode()) {
        context.fErrors->error(pos, "construction of array type '" + type.displayName() +
                "' is not supported");
        return nullptr;
    }
 
    // An array of atomics cannot be constructed.
    if (type.isOrContainsAtomic()) {
        context.fErrors->error(
                pos,
                String::printf("construction of array type '%s' with atomic member is not allowed",
                               type.displayName().c_str()));
        return nullptr;
    }
 
    // If there is a single argument containing an array of matching size and the types are
    // coercible, this is actually a cast. i.e., `half[10](myFloat10Array)`. This isn't a GLSL
    // feature, but the Pipeline stage code generator needs this functionality so that code which
    // was originally compiled with "allow narrowing conversions" enabled can be later recompiled
    // without narrowing conversions (we patch over these conversions with an explicit cast).
    if (args.size() == 1) {
        const Expression& expr = *args.front();
        const Type& exprType = expr.type();
 
        if (exprType.isArray() && exprType.canCoerceTo(type, /*allowNarrowing=*/true)) {
            return ConstructorArrayCast::Make(context, pos, type, std::move(args.front()));
        }
    }
 
    // Check that the number of constructor arguments matches the array size.
    if (type.columns() != args.size()) {
        context.fErrors->error(pos, String::printf("invalid arguments to '%s' constructor "
                "(expected %d elements, but found %d)", type.displayName().c_str(), type.columns(),
                args.size()));
        return nullptr;
    }
 
    // Convert each constructor argument to the array's component type.
    const Type& baseType = type.componentType();
    for (std::unique_ptr<Expression>& argument : args) {
        argument = baseType.coerceExpression(std::move(argument), context);
        if (!argument) {
            return nullptr;
        }
    }
 
    return ConstructorArray::Make(context, pos, type, std::move(args));
}

◆ Make()

std::unique_ptr< Expression > SkSL::ConstructorArray::Make	(	const Context &	context,
		Position	pos,
		const Type &	type,
		ExpressionArray	args
	)

static

Definition at line 79 of file SkSLConstructorArray.cpp.

                                                                         {
    SkASSERT(!context.fConfig->strictES2Mode());
    SkASSERT(type.isAllowedInES2(context));
    SkASSERT(type.columns() == args.size());
    SkASSERT(!type.isOrContainsAtomic());
    SkASSERT(std::all_of(args.begin(), args.end(), [&](const std::unique_ptr<Expression>& arg) {
        return type.componentType().matches(arg->type());
    }));
 
    return std::make_unique<ConstructorArray>(pos, type, std::move(args));
}

Member Data Documentation

◆ kIRNodeKind

constexpr Kind SkSL::ConstructorArray::kIRNodeKind = Kind::kConstructorArray

inlinestaticconstexpr

Definition at line 30 of file SkSLConstructorArray.h.

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

third_party/skia/src/sksl/ir/SkSLConstructorArray.h
third_party/skia/src/sksl/ir/SkSLConstructorArray.cpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members