commit 3b414a8de5643fdf7ff0e1aa6d162830f081c4e4
author Neel Mehta <mneel@google.com> Tue Jul 02 15:47:48 2019 -0700
committer Neel Mehta <mneel@google.com> Fri Jul 19 10:59:40 2019 -0700
tree 0df703db3d8845e6b76d13ebabd271e4be953c37
parent 8d5421845fe329fe38fca17f7d1eee736a6e600b

Add -Lformat option to format .hal files

Formats .hal files.

Bug: 137553653
Test: hidl-gen -Lformat <IFACE>
Test: aosp/1051701
Test: hidl-gen -Lformat (google-interfaces) & hidl-gen -Lcheck
(google-interfaces)
Change-Id: I5aa554d99fd4977acb7939d8c793081680a3f598

ConstantExpression.cpp

diff --git a/ConstantExpression.cpp b/ConstantExpression.cpp
index 002bf56..6badf57 100644
--- a/ConstantExpression.cpp
+++ b/ConstantExpression.cpp
@@ -164,17 +164,19 @@
     return std::make_unique<LiteralConstantExpression>(kind, value);
 }
 
+ConstantExpression::ConstantExpression(const std::string& expr) : mExpr(expr) {}
+
 bool ConstantExpression::isEvaluated() const {
     return mIsEvaluated;
 }
 
-LiteralConstantExpression::LiteralConstantExpression(
-    ScalarType::Kind kind, uint64_t value, const std::string& expr) {
-
+LiteralConstantExpression::LiteralConstantExpression(ScalarType::Kind kind, uint64_t value,
+                                                     const std::string& expr)
+    : ConstantExpression(expr) {
     CHECK(!expr.empty());
     CHECK(isSupported(kind));
+
     mTrivialDescription = std::to_string(value) == expr;
-    mExpr = expr;
     mValueKind = kind;
     mValue = value;
     mIsEvaluated = true;
@@ -254,7 +256,6 @@
     CHECK(mUnary->isEvaluated());
     mIsEvaluated = true;
 
-    mExpr = std::string("(") + mOp + mUnary->mExpr + ")";
     mValueKind = mUnary->mValueKind;
 
 #define CASE_UNARY(__type__)                                          \
@@ -270,8 +271,6 @@
     CHECK(mRval->isEvaluated());
     mIsEvaluated = true;
 
-    mExpr = std::string("(") + mLval->mExpr + " " + mOp + " " + mRval->mExpr + ")";
-
     bool isArithmeticOrBitflip = OP_IS_BIN_ARITHMETIC || OP_IS_BIN_BITFLIP;
 
     // CASE 1: + - *  / % | ^ & < > <= >= == !=
@@ -330,8 +329,6 @@
     CHECK(mFalseVal->isEvaluated());
     mIsEvaluated = true;
 
-    mExpr = std::string("(") + mCond->mExpr + "?" + mTrueVal->mExpr + ":" + mFalseVal->mExpr + ")";
-
     // note: for ?:, unlike arithmetic ops, integral promotion is not processed.
     mValueKind = usualArithmeticConversion(mTrueVal->mValueKind, mFalseVal->mValueKind);
 
@@ -466,7 +463,6 @@
 }
 
 const std::string& ConstantExpression::expression() const {
-    CHECK(isEvaluated());
     return mExpr;
 }
 
@@ -683,7 +679,7 @@
 }
 
 UnaryConstantExpression::UnaryConstantExpression(const std::string& op, ConstantExpression* value)
-    : mUnary(value), mOp(op) {}
+    : ConstantExpression(std::string("(") + op + value->mExpr + ")"), mUnary(value), mOp(op) {}
 
 std::vector<const ConstantExpression*> UnaryConstantExpression::getConstantExpressions() const {
     return {mUnary};
@@ -691,7 +687,10 @@
 
 BinaryConstantExpression::BinaryConstantExpression(ConstantExpression* lval, const std::string& op,
                                                    ConstantExpression* rval)
-    : mLval(lval), mRval(rval), mOp(op) {}
+    : ConstantExpression(std::string("(") + lval->mExpr + " " + op + " " + rval->mExpr + ")"),
+      mLval(lval),
+      mRval(rval),
+      mOp(op) {}
 
 std::vector<const ConstantExpression*> BinaryConstantExpression::getConstantExpressions() const {
     return {mLval, mRval};
@@ -700,7 +699,11 @@
 TernaryConstantExpression::TernaryConstantExpression(ConstantExpression* cond,
                                                      ConstantExpression* trueVal,
                                                      ConstantExpression* falseVal)
-    : mCond(cond), mTrueVal(trueVal), mFalseVal(falseVal) {}
+    : ConstantExpression(std::string("(") + cond->mExpr + "?" + trueVal->mExpr + ":" +
+                         falseVal->mExpr + ")"),
+      mCond(cond),
+      mTrueVal(trueVal),
+      mFalseVal(falseVal) {}
 
 std::vector<const ConstantExpression*> TernaryConstantExpression::getConstantExpressions() const {
     return {mCond, mTrueVal, mFalseVal};
@@ -708,8 +711,7 @@
 
 ReferenceConstantExpression::ReferenceConstantExpression(const Reference<LocalIdentifier>& value,
                                                          const std::string& expr)
-    : mReference(value) {
-    mExpr = expr;
+    : ConstantExpression(expr), mReference(value) {
     mTrivialDescription = mExpr.empty();
 }
 
@@ -729,9 +731,7 @@
 AttributeConstantExpression::AttributeConstantExpression(const Reference<Type>& value,
                                                          const std::string& fqname,
                                                          const std::string& tag)
-    : mReference(value), mTag(tag) {
-    mExpr = fqname + "#" + tag;
-}
+    : ConstantExpression(fqname + "#" + tag), mReference(value), mTag(tag) {}
 
 std::vector<const ConstantExpression*> AttributeConstantExpression::getConstantExpressions() const {
     // Returns reference instead