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