clang-format runtime/vm

runtime/vm/token.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_TOKEN_H_
 #define RUNTIME_VM_TOKEN_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 
@@ skipping 24 matching lines @@
 #define DART_TOKEN_LIST(TOK)                                                   \
   TOK(kEOS, "", 0, kNoAttribute)                                               \
                                                                                \
   TOK(kLPAREN, "(", 0, kNoAttribute)                                           \
   TOK(kRPAREN, ")", 0, kNoAttribute)                                           \
   TOK(kLBRACK, "[", 0, kNoAttribute)                                           \
   TOK(kRBRACK, "]", 0, kNoAttribute)                                           \
   TOK(kLBRACE, "{", 0, kNoAttribute)                                           \
   TOK(kRBRACE, "}", 0, kNoAttribute)                                           \
   TOK(kARROW, "=>", 0, kNoAttribute)                                           \
-  TOK(kCOLON,  ":", 0, kNoAttribute)                                           \
+  TOK(kCOLON, ":", 0, kNoAttribute)                                            \
   TOK(kSEMICOLON, ";", 0, kNoAttribute)                                        \
   TOK(kPERIOD, ".", 0, kNoAttribute)                                           \
   TOK(kQM_PERIOD, "?.", 0, kNoAttribute)                                       \
-  TOK(kINCR,   "++", 0, kNoAttribute)                                          \
-  TOK(kDECR,   "--", 0, kNoAttribute)                                          \
+  TOK(kINCR, "++", 0, kNoAttribute)                                            \
+  TOK(kDECR, "--", 0, kNoAttribute)                                            \
                                                                                \
   /* Assignment operators.                            */                       \
   /* Please update IsAssignmentOperator() if you make */                       \
   /* any changes to this block.                       */                       \
   TOK(kASSIGN, "=", 2, kNoAttribute)                                           \
   TOK(kASSIGN_OR, "|=", 2, kNoAttribute)                                       \
   TOK(kASSIGN_XOR, "^=", 2, kNoAttribute)                                      \
   TOK(kASSIGN_AND, "&=", 2, kNoAttribute)                                      \
   TOK(kASSIGN_SHL, "<<=", 2, kNoAttribute)                                     \
   TOK(kASSIGN_SHR, ">>=", 2, kNoAttribute)                                     \
@@ skipping 71 matching lines @@
                                                                                \
   TOK(kNEWLINE, "\n", 0, kNoAttribute)                                         \
   TOK(kWHITESP, "", 0, kNoAttribute)                                           \
   TOK(kERROR, "", 0, kNoAttribute)                                             \
   TOK(kILLEGAL, "", 0, kNoAttribute)                                           \
                                                                                \
   /* Support for Dart scripts. */                                              \
   TOK(kSCRIPTTAG, "#!", 0, kNoAttribute)                                       \
                                                                                \
   /* Support for optimized code */                                             \
-  TOK(kREM, "", 0, kNoAttribute)                                               \
+  TOK(kREM, "", 0, kNoAttribute)
 
 // List of keywords. The list must be alphabetically ordered. The
 // keyword recognition code depends on the ordering.
 // If you add a keyword at the beginning or end of this list, make sure
 // to update kFirstKeyword and kLastKeyword below.
 #define DART_KEYWORD_LIST(KW)                                                  \
   KW(kABSTRACT, "abstract", 0, kPseudoKeyword) /* == kFirstKeyword */          \
   KW(kAS, "as", 11, kPseudoKeyword)                                            \
   KW(kASSERT, "assert", 11, kKeyword)                                          \
   KW(kBREAK, "break", 0, kKeyword)                                             \
@@ skipping 39 matching lines @@
   KW(kVAR, "var", 0, kKeyword)                                                 \
   KW(kVOID, "void", 0, kKeyword)                                               \
   KW(kWHILE, "while", 0, kKeyword)                                             \
   KW(kWITH, "with", 0, kKeyword) /* == kLastKeyword */
 
 class String;
 
 class Token {
  public:
 #define T(t, s, p, a) t,
-  enum Kind {
-    DART_TOKEN_LIST(T)
-    DART_KEYWORD_LIST(T)
-    kNumTokens
-  };
+  enum Kind { DART_TOKEN_LIST(T) DART_KEYWORD_LIST(T) kNumTokens };
 #undef T
 
   enum Attribute {
-    kNoAttribute     = 0,
-    kKeyword         = 1 << 0,
-    kPseudoKeyword   = 1 << 1,
+    kNoAttribute = 0,
+    kKeyword = 1 << 0,
+    kPseudoKeyword = 1 << 1,
   };
 
   static const Kind kFirstKeyword = kABSTRACT;
   static const Kind kLastKeyword = kWITH;
   static const int kNumKeywords = kLastKeyword - kFirstKeyword + 1;
 
   static bool IsAssignmentOperator(Kind tok) {
     return kASSIGN <= tok && tok <= kASSIGN_COND;
   }
 
   static bool IsRelationalOperator(Kind tok) {
     return kLT <= tok && tok <= kGTE;
   }
 
   static bool IsEqualityOperator(Kind tok) {
     return kEQ <= tok && tok <= kNE_STRICT;
   }
 
   static bool IsStrictEqualityOperator(Kind tok) {
     return (tok == kEQ_STRICT) || (tok == kNE_STRICT);
   }
 
   static bool IsTypeTestOperator(Kind tok) {
     return (tok == kIS) || (tok == kISNOT);
   }
 
-  static bool IsTypeCastOperator(Kind tok) {
-    return tok == kAS;
-  }
+  static bool IsTypeCastOperator(Kind tok) { return tok == kAS; }
 
   static bool IsIndexOperator(Kind tok) {
     return tok == kINDEX || tok == kASSIGN_INDEX;
   }
 
   static bool IsPseudoKeyword(Kind tok) {
     return (Attributes(tok) & kPseudoKeyword) != 0;
   }
 
-  static bool IsKeyword(Kind tok) {
-    return (Attributes(tok) & kKeyword) != 0;
-  }
+  static bool IsKeyword(Kind tok) { return (Attributes(tok) & kKeyword) != 0; }
 
   static bool IsIdentifier(Kind tok) {
     return (tok == kIDENT) || IsPseudoKeyword(tok);
   }
 
   static const char* Name(Kind tok) {
     ASSERT(tok < kNumTokens);
     return name_[tok];
   }
 
   static const char* Str(Kind tok) {
     ASSERT(tok < kNumTokens);
     return tok_str_[tok];
   }
 
   static int Precedence(Kind tok) {
     ASSERT(tok < kNumTokens);
     return precedence_[tok];
   }
 
   static Attribute Attributes(Kind tok) {
     ASSERT(tok < kNumTokens);
     return attributes_[tok];
   }
 
   static bool CanBeOverloaded(Kind tok) {
     ASSERT(tok < kNumTokens);
-    return IsRelationalOperator(tok) ||
-           (tok == kEQ) ||
-           (tok >= kADD && tok <= kMOD) ||  // Arithmetic operations.
+    return IsRelationalOperator(tok) || (tok == kEQ) ||
+           (tok >= kADD && tok <= kMOD) ||     // Arithmetic operations.
            (tok >= kBIT_OR && tok <= kSHR) ||  // Bit operations.
-           (tok == kINDEX) ||
-           (tok == kASSIGN_INDEX);
+           (tok == kINDEX) || (tok == kASSIGN_INDEX);
   }
 
   static bool NeedsLiteralToken(Kind tok) {
     ASSERT(tok < kNumTokens);
-    return ((tok == Token::kINTEGER) ||
-            (tok == Token::kSTRING) ||
-            (tok == Token::kINTERPOL_VAR) ||
-            (tok == Token::kERROR) ||
+    return ((tok == Token::kINTEGER) || (tok == Token::kSTRING) ||
+            (tok == Token::kINTERPOL_VAR) || (tok == Token::kERROR) ||
             (tok == Token::kDOUBLE));
   }
 
   static bool IsBinaryOperator(Token::Kind token);
   static bool IsUnaryOperator(Token::Kind token);
 
   static bool IsBinaryArithmeticOperator(Token::Kind token);
   static bool IsUnaryArithmeticOperator(Token::Kind token);
 
   // For a comparison operation return an operation for the negated comparison:
   // !(a (op) b) === a (op') b
   static Token::Kind NegateComparison(Token::Kind op) {
     switch (op) {
-      case Token::kEQ: return Token::kNE;
-      case Token::kNE: return Token::kEQ;
-      case Token::kLT: return Token::kGTE;
-      case Token::kGT: return Token::kLTE;
-      case Token::kLTE: return Token::kGT;
-      case Token::kGTE: return Token::kLT;
-      case Token::kEQ_STRICT: return Token::kNE_STRICT;
-      case Token::kNE_STRICT: return Token::kEQ_STRICT;
-      case Token::kIS:    return Token::kISNOT;
-      case Token::kISNOT: return Token::kIS;
+      case Token::kEQ:
+        return Token::kNE;
+      case Token::kNE:
+        return Token::kEQ;
+      case Token::kLT:
+        return Token::kGTE;
+      case Token::kGT:
+        return Token::kLTE;
+      case Token::kLTE:
+        return Token::kGT;
+      case Token::kGTE:
+        return Token::kLT;
+      case Token::kEQ_STRICT:
+        return Token::kNE_STRICT;
+      case Token::kNE_STRICT:
+        return Token::kEQ_STRICT;
+      case Token::kIS:
+        return Token::kISNOT;
+      case Token::kISNOT:
+        return Token::kIS;
       default:
         UNREACHABLE();
         return Token::kILLEGAL;
     }
   }
 
  private:
   static const char* name_[];
   static const char* tok_str_[];
   static const uint8_t precedence_[];
   static const Attribute attributes_[];
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_TOKEN_H_