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(int offset, Kind kind, const Type& type) 48 : INHERITED(offset) 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 * For an expression which evaluates to a constant int, returns the value. Otherwise calls 71 * ABORT. 72 */ getConstantIntExpression73 virtual int64_t getConstantInt() const { 74 ABORT("not a constant int"); 75 } 76 77 /** 78 * For an expression which evaluates to a constant float, returns the value. Otherwise calls 79 * ABORT. 80 */ getConstantFloatExpression81 virtual double getConstantFloat() const { 82 ABORT("not a constant float"); 83 } 84 85 /** 86 * Returns true if evaluating the expression potentially has side effects. Expressions may never 87 * return false if they actually have side effects, but it is legal (though suboptimal) to 88 * return true if there are not actually any side effects. 89 */ 90 virtual bool hasSideEffects() const = 0; 91 92 /** 93 * Given a map of known constant variable values, substitute them in for references to those 94 * variables occurring in this expression and its subexpressions. Similar simplifications, such 95 * as folding a constant binary expression down to a single value, may also be performed. 96 * Returns a new expression which replaces this expression, or null if no replacements were 97 * made. If a new expression is returned, this expression is no longer valid. 98 */ constantPropagateExpression99 virtual std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator, 100 const DefinitionMap& definitions) { 101 return nullptr; 102 } 103 coercionCostExpression104 virtual int coercionCost(const Type& target) const { 105 return fType.coercionCost(target); 106 } 107 108 const Kind fKind; 109 const Type& fType; 110 111 typedef IRNode INHERITED; 112 }; 113 114 } // namespace 115 116 #endif 117