Andreas Huber | 1aec397 | 2016-08-26 09:26:32 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 17 | #ifndef CONSTANT_EXPRESSION_H_ |
| 18 | |
| 19 | #define CONSTANT_EXPRESSION_H_ |
| 20 | |
| 21 | #include <android-base/macros.h> |
Timur Iskhakov | 891a866 | 2017-08-25 21:53:48 -0700 | [diff] [blame] | 22 | #include <functional> |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 23 | #include <memory> |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 24 | #include <string> |
Timur Iskhakov | 891a866 | 2017-08-25 21:53:48 -0700 | [diff] [blame] | 25 | #include <unordered_set> |
| 26 | #include <vector> |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 27 | |
| 28 | #include "Reference.h" |
Yifan Hong | 5788697 | 2016-08-17 10:42:15 -0700 | [diff] [blame] | 29 | #include "ScalarType.h" |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 30 | |
| 31 | namespace android { |
| 32 | |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 33 | struct LocalIdentifier; |
| 34 | |
| 35 | struct LiteralConstantExpression; |
| 36 | struct UnaryConstantExpression; |
| 37 | struct BinaryConstantExpression; |
| 38 | struct TernaryConstantExpression; |
| 39 | struct ReferenceConstantExpression; |
| 40 | |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 41 | /** |
| 42 | * A constant expression is represented by a tree. |
| 43 | */ |
| 44 | struct ConstantExpression { |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 45 | static std::unique_ptr<ConstantExpression> Zero(ScalarType::Kind kind); |
| 46 | static std::unique_ptr<ConstantExpression> One(ScalarType::Kind kind); |
| 47 | static std::unique_ptr<ConstantExpression> ValueOf(ScalarType::Kind kind, uint64_t value); |
Yifan Hong | 5788697 | 2016-08-17 10:42:15 -0700 | [diff] [blame] | 48 | |
Neel Mehta | 3b414a8 | 2019-07-02 15:47:48 -0700 | [diff] [blame] | 49 | ConstantExpression(const std::string& expr); |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 50 | virtual ~ConstantExpression() {} |
Yifan Hong | 5788697 | 2016-08-17 10:42:15 -0700 | [diff] [blame] | 51 | |
Timur Iskhakov | a6d3388 | 2017-09-01 13:02:09 -0700 | [diff] [blame] | 52 | virtual bool isReferenceConstantExpression() const; |
| 53 | |
Neel Mehta | 1ca3e78 | 2019-07-18 15:16:22 -0700 | [diff] [blame] | 54 | void surroundWithParens(); |
| 55 | |
Timur Iskhakov | 891a866 | 2017-08-25 21:53:48 -0700 | [diff] [blame] | 56 | // Proceeds recursive pass |
| 57 | // Makes sure to visit each node only once |
| 58 | // Used to provide lookup and lazy evaluation |
| 59 | status_t recursivePass(const std::function<status_t(ConstantExpression*)>& func, |
Timur Iskhakov | 82c048e | 2017-09-09 01:20:53 -0700 | [diff] [blame] | 60 | std::unordered_set<const ConstantExpression*>* visited, |
| 61 | bool processBeforeDependencies); |
Timur Iskhakov | b58f418 | 2017-08-29 15:19:24 -0700 | [diff] [blame] | 62 | status_t recursivePass(const std::function<status_t(const ConstantExpression*)>& func, |
Timur Iskhakov | 82c048e | 2017-09-09 01:20:53 -0700 | [diff] [blame] | 63 | std::unordered_set<const ConstantExpression*>* visited, |
| 64 | bool processBeforeDependencies) const; |
Timur Iskhakov | 891a866 | 2017-08-25 21:53:48 -0700 | [diff] [blame] | 65 | |
Steven Moreland | 12f0ab1 | 2018-11-02 17:27:37 -0700 | [diff] [blame] | 66 | // If this object is in an invalid state. |
| 67 | virtual status_t validate() const; |
| 68 | |
Timur Iskhakov | 891a866 | 2017-08-25 21:53:48 -0700 | [diff] [blame] | 69 | // Evaluates current constant expression |
| 70 | // Doesn't call recursive evaluation, so must be called after dependencies |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 71 | virtual void evaluate() = 0; |
Colin Cross | a549b71 | 2017-08-09 18:33:22 +0000 | [diff] [blame] | 72 | |
Timur Iskhakov | b58f418 | 2017-08-29 15:19:24 -0700 | [diff] [blame] | 73 | std::vector<ConstantExpression*> getConstantExpressions(); |
| 74 | virtual std::vector<const ConstantExpression*> getConstantExpressions() const = 0; |
Timur Iskhakov | 891a866 | 2017-08-25 21:53:48 -0700 | [diff] [blame] | 75 | |
Timur Iskhakov | 77dd65c | 2017-08-31 22:46:56 -0700 | [diff] [blame] | 76 | std::vector<Reference<LocalIdentifier>*> getReferences(); |
| 77 | virtual std::vector<const Reference<LocalIdentifier>*> getReferences() const; |
| 78 | |
Steven Moreland | 12f0ab1 | 2018-11-02 17:27:37 -0700 | [diff] [blame] | 79 | std::vector<Reference<Type>*> getTypeReferences(); |
| 80 | virtual std::vector<const Reference<Type>*> getTypeReferences() const; |
| 81 | |
Timur Iskhakov | 77dd65c | 2017-08-31 22:46:56 -0700 | [diff] [blame] | 82 | // Recursive tree pass checkAcyclic return type. |
| 83 | // Stores cycle end for nice error messages. |
| 84 | struct CheckAcyclicStatus { |
Timur Iskhakov | a6d3388 | 2017-09-01 13:02:09 -0700 | [diff] [blame] | 85 | CheckAcyclicStatus(status_t status, const ConstantExpression* cycleEnd = nullptr, |
| 86 | const ReferenceConstantExpression* lastReferenceExpression = nullptr); |
Timur Iskhakov | 77dd65c | 2017-08-31 22:46:56 -0700 | [diff] [blame] | 87 | |
| 88 | status_t status; |
| 89 | |
| 90 | // If a cycle is found, stores the end of cycle. |
| 91 | // While going back in recursion, this is used to stop printing the cycle. |
| 92 | const ConstantExpression* cycleEnd; |
Timur Iskhakov | a6d3388 | 2017-09-01 13:02:09 -0700 | [diff] [blame] | 93 | |
| 94 | // The last ReferenceConstantExpression visited on the cycle. |
| 95 | const ReferenceConstantExpression* lastReference; |
Timur Iskhakov | 77dd65c | 2017-08-31 22:46:56 -0700 | [diff] [blame] | 96 | }; |
| 97 | |
| 98 | // Recursive tree pass that ensures that constant expressions definitions |
| 99 | // are acyclic. |
| 100 | CheckAcyclicStatus checkAcyclic(std::unordered_set<const ConstantExpression*>* visited, |
| 101 | std::unordered_set<const ConstantExpression*>* stack) const; |
| 102 | |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 103 | /* Returns true iff the value has already been evaluated. */ |
| 104 | bool isEvaluated() const; |
Steven Moreland | f21962d | 2018-08-09 12:44:40 -0700 | [diff] [blame] | 105 | /* Evaluated result in a string form with comment if applicable. */ |
Yifan Hong | fc610cd | 2016-09-22 13:34:45 -0700 | [diff] [blame] | 106 | std::string value() const; |
Steven Moreland | f21962d | 2018-08-09 12:44:40 -0700 | [diff] [blame] | 107 | /* Evaluated result in a string form with comment if applicable. */ |
Yifan Hong | f24fa85 | 2016-09-23 11:03:15 -0700 | [diff] [blame] | 108 | std::string cppValue() const; |
Steven Moreland | f21962d | 2018-08-09 12:44:40 -0700 | [diff] [blame] | 109 | /* Evaluated result in a string form with comment if applicable. */ |
Yifan Hong | f24fa85 | 2016-09-23 11:03:15 -0700 | [diff] [blame] | 110 | std::string javaValue() const; |
Yifan Hong | 5788697 | 2016-08-17 10:42:15 -0700 | [diff] [blame] | 111 | /* Evaluated result in a string form, with given contextual kind. */ |
Yifan Hong | c07b202 | 2016-11-08 12:44:24 -0800 | [diff] [blame] | 112 | std::string value(ScalarType::Kind castKind) const; |
| 113 | /* Evaluated result in a string form, with given contextual kind. */ |
Yifan Hong | fc610cd | 2016-09-22 13:34:45 -0700 | [diff] [blame] | 114 | std::string cppValue(ScalarType::Kind castKind) const; |
Yifan Hong | 19ca75a | 2016-08-31 10:20:03 -0700 | [diff] [blame] | 115 | /* Evaluated result in a string form, with given contextual kind. */ |
Yifan Hong | fc610cd | 2016-09-22 13:34:45 -0700 | [diff] [blame] | 116 | std::string javaValue(ScalarType::Kind castKind) const; |
Steven Moreland | f21962d | 2018-08-09 12:44:40 -0700 | [diff] [blame] | 117 | |
| 118 | /* The expression representing this value for use in comments when the value is not needed */ |
| 119 | const std::string& expression() const; |
| 120 | |
Yifan Hong | f24fa85 | 2016-09-23 11:03:15 -0700 | [diff] [blame] | 121 | /* Return a ConstantExpression that is 1 plus the original. */ |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 122 | std::unique_ptr<ConstantExpression> addOne(ScalarType::Kind baseKind); |
Yifan Hong | e77ca13 | 2016-09-27 10:49:05 -0700 | [diff] [blame] | 123 | |
| 124 | size_t castSizeT() const; |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 125 | |
Timur Iskhakov | 35930c4 | 2017-08-28 18:49:54 -0700 | [diff] [blame] | 126 | // Marks that package proceeding is completed |
| 127 | // Post parse passes must be proceeded during owner package parsin |
| 128 | void setPostParseCompleted(); |
| 129 | |
Steven Moreland | f21962d | 2018-08-09 12:44:40 -0700 | [diff] [blame] | 130 | /* |
| 131 | * Helper function for all cpp/javaValue methods. |
| 132 | * Returns a plain string (without any prefixes or suffixes, just the |
| 133 | * digits) converted from mValue. |
| 134 | */ |
| 135 | std::string rawValue() const; |
| 136 | std::string rawValue(ScalarType::Kind castKind) const; |
| 137 | |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 138 | private: |
| 139 | /* If the result value has been evaluated. */ |
| 140 | bool mIsEvaluated = false; |
Yifan Hong | 5788697 | 2016-08-17 10:42:15 -0700 | [diff] [blame] | 141 | /* The formatted expression. */ |
Neel Mehta | 1ca3e78 | 2019-07-18 15:16:22 -0700 | [diff] [blame] | 142 | std::string mExpr; |
Yifan Hong | f24fa85 | 2016-09-23 11:03:15 -0700 | [diff] [blame] | 143 | /* The kind of the result value. */ |
Yifan Hong | 5788697 | 2016-08-17 10:42:15 -0700 | [diff] [blame] | 144 | ScalarType::Kind mValueKind; |
Yifan Hong | f24fa85 | 2016-09-23 11:03:15 -0700 | [diff] [blame] | 145 | /* The stored result value. */ |
Yifan Hong | 5788697 | 2016-08-17 10:42:15 -0700 | [diff] [blame] | 146 | uint64_t mValue; |
Yifan Hong | 5706a43 | 2016-11-02 09:44:18 -0700 | [diff] [blame] | 147 | /* true if description() does not offer more information than value(). */ |
| 148 | bool mTrivialDescription = false; |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 149 | |
Timur Iskhakov | 35930c4 | 2017-08-28 18:49:54 -0700 | [diff] [blame] | 150 | bool mIsPostParseCompleted = false; |
| 151 | |
Yifan Hong | f24fa85 | 2016-09-23 11:03:15 -0700 | [diff] [blame] | 152 | /* |
Steven Moreland | f21962d | 2018-08-09 12:44:40 -0700 | [diff] [blame] | 153 | * Helper function, gives suffix comment to add to value/cppValue/javaValue |
Yifan Hong | f24fa85 | 2016-09-23 11:03:15 -0700 | [diff] [blame] | 154 | */ |
Steven Moreland | f21962d | 2018-08-09 12:44:40 -0700 | [diff] [blame] | 155 | std::string descriptionSuffix() const; |
Yifan Hong | e77ca13 | 2016-09-27 10:49:05 -0700 | [diff] [blame] | 156 | |
| 157 | /* |
| 158 | * Return the value casted to the given type. |
| 159 | * First cast it according to mValueKind, then cast it to T. |
| 160 | * Assumes !containsIdentifiers() |
| 161 | */ |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 162 | template <typename T> |
| 163 | T cast() const; |
| 164 | |
| 165 | friend struct LiteralConstantExpression; |
| 166 | friend struct UnaryConstantExpression; |
| 167 | friend struct BinaryConstantExpression; |
| 168 | friend struct TernaryConstantExpression; |
| 169 | friend struct ReferenceConstantExpression; |
Steven Moreland | 12f0ab1 | 2018-11-02 17:27:37 -0700 | [diff] [blame] | 170 | friend struct AttributeConstantExpression; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 171 | }; |
| 172 | |
| 173 | struct LiteralConstantExpression : public ConstantExpression { |
| 174 | LiteralConstantExpression(ScalarType::Kind kind, uint64_t value); |
Steven Moreland | 7794369 | 2018-08-09 12:53:42 -0700 | [diff] [blame] | 175 | LiteralConstantExpression(ScalarType::Kind kind, uint64_t value, const std::string& expr); |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 176 | void evaluate() override; |
Timur Iskhakov | b58f418 | 2017-08-29 15:19:24 -0700 | [diff] [blame] | 177 | std::vector<const ConstantExpression*> getConstantExpressions() const override; |
Steven Moreland | d9d6dcb | 2017-09-20 15:55:39 -0700 | [diff] [blame] | 178 | |
| 179 | static LiteralConstantExpression* tryParse(const std::string& value); |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 180 | }; |
| 181 | |
| 182 | struct UnaryConstantExpression : public ConstantExpression { |
Timur Iskhakov | d27580c | 2017-08-09 20:14:52 -0700 | [diff] [blame] | 183 | UnaryConstantExpression(const std::string& mOp, ConstantExpression* value); |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 184 | void evaluate() override; |
Timur Iskhakov | b58f418 | 2017-08-29 15:19:24 -0700 | [diff] [blame] | 185 | std::vector<const ConstantExpression*> getConstantExpressions() const override; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 186 | |
| 187 | private: |
Timur Iskhakov | d27580c | 2017-08-09 20:14:52 -0700 | [diff] [blame] | 188 | ConstantExpression* const mUnary; |
| 189 | std::string mOp; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 190 | }; |
| 191 | |
| 192 | struct BinaryConstantExpression : public ConstantExpression { |
| 193 | BinaryConstantExpression(ConstantExpression* lval, const std::string& op, |
| 194 | ConstantExpression* rval); |
| 195 | void evaluate() override; |
Timur Iskhakov | b58f418 | 2017-08-29 15:19:24 -0700 | [diff] [blame] | 196 | std::vector<const ConstantExpression*> getConstantExpressions() const override; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 197 | |
| 198 | private: |
Timur Iskhakov | d27580c | 2017-08-09 20:14:52 -0700 | [diff] [blame] | 199 | ConstantExpression* const mLval; |
| 200 | ConstantExpression* const mRval; |
| 201 | const std::string mOp; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 202 | }; |
| 203 | |
| 204 | struct TernaryConstantExpression : public ConstantExpression { |
| 205 | TernaryConstantExpression(ConstantExpression* cond, ConstantExpression* trueVal, |
| 206 | ConstantExpression* falseVal); |
| 207 | void evaluate() override; |
Timur Iskhakov | b58f418 | 2017-08-29 15:19:24 -0700 | [diff] [blame] | 208 | std::vector<const ConstantExpression*> getConstantExpressions() const override; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 209 | |
| 210 | private: |
Timur Iskhakov | d27580c | 2017-08-09 20:14:52 -0700 | [diff] [blame] | 211 | ConstantExpression* const mCond; |
| 212 | ConstantExpression* const mTrueVal; |
| 213 | ConstantExpression* const mFalseVal; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 214 | }; |
| 215 | |
| 216 | struct ReferenceConstantExpression : public ConstantExpression { |
| 217 | ReferenceConstantExpression(const Reference<LocalIdentifier>& value, const std::string& expr); |
Timur Iskhakov | a6d3388 | 2017-09-01 13:02:09 -0700 | [diff] [blame] | 218 | |
| 219 | bool isReferenceConstantExpression() const override; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 220 | void evaluate() override; |
Timur Iskhakov | b58f418 | 2017-08-29 15:19:24 -0700 | [diff] [blame] | 221 | std::vector<const ConstantExpression*> getConstantExpressions() const override; |
Timur Iskhakov | 77dd65c | 2017-08-31 22:46:56 -0700 | [diff] [blame] | 222 | std::vector<const Reference<LocalIdentifier>*> getReferences() const override; |
Timur Iskhakov | 7296af1 | 2017-08-09 21:52:48 +0000 | [diff] [blame] | 223 | |
| 224 | private: |
Timur Iskhakov | d27580c | 2017-08-09 20:14:52 -0700 | [diff] [blame] | 225 | Reference<LocalIdentifier> mReference; |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 226 | }; |
| 227 | |
Steven Moreland | 12f0ab1 | 2018-11-02 17:27:37 -0700 | [diff] [blame] | 228 | // This constant expression is a compile-time calculatable expression based on another type |
| 229 | struct AttributeConstantExpression : public ConstantExpression { |
| 230 | AttributeConstantExpression(const Reference<Type>& value, const std::string& fqname, |
| 231 | const std::string& tag); |
| 232 | |
| 233 | status_t validate() const override; |
| 234 | void evaluate() override; |
| 235 | |
| 236 | std::vector<const ConstantExpression*> getConstantExpressions() const override; |
| 237 | std::vector<const Reference<Type>*> getTypeReferences() const override; |
| 238 | |
| 239 | private: |
| 240 | Reference<Type> mReference; |
| 241 | const std::string mTag; |
| 242 | }; |
| 243 | |
Yifan Hong | 5216569 | 2016-08-12 18:06:40 -0700 | [diff] [blame] | 244 | } // namespace android |
| 245 | |
| 246 | #endif // CONSTANT_EXPRESSION_H_ |