1 /* 2 * Copyright 2016 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SKSL_EXPRESSION 9 #define SKSL_EXPRESSION 10 11 #include "SkSLType.h" 12 #include "SkSLVariable.h" 13 14 #include <unordered_map> 15 16 namespace SkSL { 17 18 struct Expression; 19 class IRGenerator; 20 21 typedef std::unordered_map<const Variable*, std::unique_ptr<Expression>*> DefinitionMap; 22 23 /** 24 * Abstract supertype of all expressions. 25 */ 26 struct Expression : public IRNode { 27 enum Kind { 28 kBinary_Kind, 29 kBoolLiteral_Kind, 30 kConstructor_Kind, 31 kIntLiteral_Kind, 32 kFieldAccess_Kind, 33 kFloatLiteral_Kind, 34 kFunctionReference_Kind, 35 kFunctionCall_Kind, 36 kIndex_Kind, 37 kPrefix_Kind, 38 kPostfix_Kind, 39 kSetting_Kind, 40 kSwizzle_Kind, 41 kVariableReference_Kind, 42 kTernary_Kind, 43 kTypeReference_Kind, 44 kDefined_Kind 45 }; 46 ExpressionExpression47 Expression(Position position, Kind kind, const Type& type) 48 : INHERITED(position) 49 , fKind(kind) 50 , fType(std::move(type)) {} 51 52 /** 53 * Returns true if this expression is constant. compareConstant must be implemented for all 54 * constants! 55 */ isConstantExpression56 virtual bool isConstant() const { 57 return false; 58 } 59 60 /** 61 * Compares this constant expression against another constant expression of the same type. It is 62 * an error to call this on non-constant expressions, or if the types of the expressions do not 63 * match. 64 */ compareConstantExpression65 virtual bool compareConstant(const Context& context, const Expression& other) const { 66 ABORT("cannot call compareConstant on this type"); 67 } 68 69 /** 70 * Returns true if evaluating the expression potentially has side effects. Expressions may never 71 * return false if they actually have side effects, but it is legal (though suboptimal) to 72 * return true if there are not actually any side effects. 73 */ 74 virtual bool hasSideEffects() const = 0; 75 76 /** 77 * Given a map of known constant variable values, substitute them in for references to those 78 * variables occurring in this expression and its subexpressions. Similar simplifications, such 79 * as folding a constant binary expression down to a single value, may also be performed. 80 * Returns a new expression which replaces this expression, or null if no replacements were 81 * made. If a new expression is returned, this expression is no longer valid. 82 */ constantPropagateExpression83 virtual std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator, 84 const DefinitionMap& definitions) { 85 return nullptr; 86 } 87 88 const Kind fKind; 89 const Type& fType; 90 91 typedef IRNode INHERITED; 92 }; 93 94 } // namespace 95 96 #endif 97