clang-format runtime/vm

runtime/vm/symbols.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_SYMBOLS_H_
 #define RUNTIME_VM_SYMBOLS_H_
 
 #include "vm/growable_array.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
@@ skipping 212 matching lines @@
   V(Uint16List, "Uint16List")                                                  \
   V(Int32List, "Int32List")                                                    \
   V(Uint32List, "Uint32List")                                                  \
   V(Int64List, "Int64List")                                                    \
   V(Uint64List, "Uint64List")                                                  \
   V(Float32x4List, "Float32x4List")                                            \
   V(Int32x4List, "Int32x4List")                                                \
   V(Float64x2List, "Float64x2List")                                            \
   V(Float32List, "Float32List")                                                \
   V(Float64List, "Float64List")                                                \
-  V(_Int8ArrayFactory, "Int8List.")                                          \
-  V(_Uint8ArrayFactory, "Uint8List.")                                        \
-  V(_Uint8ClampedArrayFactory, "Uint8ClampedList.")                          \
-  V(_Int16ArrayFactory, "Int16List.")                                        \
-  V(_Uint16ArrayFactory, "Uint16List.")                                      \
-  V(_Int32ArrayFactory, "Int32List.")                                        \
-  V(_Uint32ArrayFactory, "Uint32List.")                                      \
-  V(_Int64ArrayFactory, "Int64List.")                                        \
-  V(_Uint64ArrayFactory, "Uint64List.")                                      \
-  V(_Float32x4ArrayFactory, "Float32x4List.")                                \
-  V(_Int32x4ArrayFactory, "Int32x4List.")                                    \
-  V(_Float64x2ArrayFactory, "Float64x2List.")                                \
-  V(_Float32ArrayFactory, "Float32List.")                                    \
-  V(_Float64ArrayFactory, "Float64List.")                                    \
+  V(_Int8ArrayFactory, "Int8List.")                                            \
+  V(_Uint8ArrayFactory, "Uint8List.")                                          \
+  V(_Uint8ClampedArrayFactory, "Uint8ClampedList.")                            \
+  V(_Int16ArrayFactory, "Int16List.")                                          \
+  V(_Uint16ArrayFactory, "Uint16List.")                                        \
+  V(_Int32ArrayFactory, "Int32List.")                                          \
+  V(_Uint32ArrayFactory, "Uint32List.")                                        \
+  V(_Int64ArrayFactory, "Int64List.")                                          \
+  V(_Uint64ArrayFactory, "Uint64List.")                                        \
+  V(_Float32x4ArrayFactory, "Float32x4List.")                                  \
+  V(_Int32x4ArrayFactory, "Int32x4List.")                                      \
+  V(_Float64x2ArrayFactory, "Float64x2List.")                                  \
+  V(_Float32ArrayFactory, "Float32List.")                                      \
+  V(_Float64ArrayFactory, "Float64List.")                                      \
   V(_Int8ArrayView, "_Int8ArrayView")                                          \
   V(_Uint8ArrayView, "_Uint8ArrayView")                                        \
   V(_Uint8ClampedArrayView, "_Uint8ClampedArrayView")                          \
   V(_Int16ArrayView, "_Int16ArrayView")                                        \
   V(_Uint16ArrayView, "_Uint16ArrayView")                                      \
   V(_Int32ArrayView, "_Int32ArrayView")                                        \
   V(_Uint32ArrayView, "_Uint32ArrayView")                                      \
   V(_Int64ArrayView, "_Int64ArrayView")                                        \
   V(_Uint64ArrayView, "_Uint64ArrayView")                                      \
   V(_Float32ArrayView, "_Float32ArrayView")                                    \
@@ skipping 140 matching lines @@
   V(add, "add")                                                                \
   V(ConstructorClosurePrefix, "new#")                                          \
   V(_runExtension, "_runExtension")                                            \
   V(_runPendingImmediateCallback, "_runPendingImmediateCallback")              \
   V(DartLibrary, "dart.library.")                                              \
   V(DartLibraryMirrors, "dart.library.mirrors")                                \
   V(_name, "_name")                                                            \
   V(_classRangeCheck, "_classRangeCheck")                                      \
   V(_classRangeCheckNegative, "_classRangeCheckNegative")                      \
   V(GetRuntimeType, "get:runtimeType")                                         \
-  V(HaveSameRuntimeType, "_haveSameRuntimeType")                               \
+  V(HaveSameRuntimeType, "_haveSameRuntimeType")
 
 
 // Contains a list of frequently used strings in a canonicalized form. This
 // list is kept in the vm_isolate in order to share the copy across isolates
 // without having to maintain copies in each isolate.
 class Symbols : public AllStatic {
  public:
   enum { kMaxOneCharCodeSymbol = 0xFF };
 
   // List of strings that are pre created in the vm isolate.
   enum SymbolId {
+    // clang-format off
     kIllegal = 0,
 
-#define DEFINE_SYMBOL_INDEX(symbol, literal)                                   \
-    k##symbol##Id,
+#define DEFINE_SYMBOL_INDEX(symbol, literal) k##symbol##Id,
     PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_INDEX)
 #undef DEFINE_SYMBOL_INDEX
 
     kTokenTableStart,  // First token at kTokenTableStart + 1.
 
-#define DEFINE_TOKEN_SYMBOL_INDEX(t, s, p, a)                                  \
-    t##Id,
-    DART_TOKEN_LIST(DEFINE_TOKEN_SYMBOL_INDEX)
-    DART_KEYWORD_LIST(DEFINE_TOKEN_SYMBOL_INDEX)
+#define DEFINE_TOKEN_SYMBOL_INDEX(t, s, p, a) t##Id,
+    DART_TOKEN_LIST(DEFINE_TOKEN_SYMBOL_INDEX) DART_KEYWORD_LIST(
+        DEFINE_TOKEN_SYMBOL_INDEX)
 #undef DEFINE_TOKEN_SYMBOL_INDEX
 
     kNullCharId,  // One char code symbol starts here and takes up 256 entries.
     kMaxPredefinedId = kNullCharId + kMaxOneCharCodeSymbol + 1,
+    // clang-format on
   };
 
   // Number of one character symbols being predefined in the predefined_ array.
   static const int kNumberOfOneCharCodeSymbols =
       (kMaxPredefinedId - kNullCharId);
 
   // Offset of Null character which is the predefined character symbol.
   static const int kNullCharCodeSymbolOffset = 0;
 
   static const String& Symbol(intptr_t index) {
     ASSERT((index > kIllegal) && (index < kMaxPredefinedId));
     return *(symbol_handles_[index]);
   }
 
   // Access methods for one byte character symbols stored in the vm isolate.
-  static const String& Dot() {
-    return *(symbol_handles_[kNullCharId + '.']);
-  }
+  static const String& Dot() { return *(symbol_handles_[kNullCharId + '.']); }
   static const String& Equals() {
     return *(symbol_handles_[kNullCharId + '=']);
   }
-  static const String& Plus() {
-    return *(symbol_handles_[kNullCharId + '+']);
-  }
-  static const String& Minus() {
-    return *(symbol_handles_[kNullCharId + '-']);
-  }
-  static const String& BitOr() {
-    return *(symbol_handles_[kNullCharId + '|']);
-  }
+  static const String& Plus() { return *(symbol_handles_[kNullCharId + '+']); }
+  static const String& Minus() { return *(symbol_handles_[kNullCharId + '-']); }
+  static const String& BitOr() { return *(symbol_handles_[kNullCharId + '|']); }
   static const String& BitAnd() {
     return *(symbol_handles_[kNullCharId + '&']);
   }
   static const String& LAngleBracket() {
     return *(symbol_handles_[kNullCharId + '<']);
   }
   static const String& RAngleBracket() {
     return *(symbol_handles_[kNullCharId + '>']);
   }
   static const String& LParen() {
     return *(symbol_handles_[kNullCharId + '(']);
   }
   static const String& RParen() {
     return *(symbol_handles_[kNullCharId + ')']);
   }
   static const String& LBracket() {
     return *(symbol_handles_[kNullCharId + '[']);
   }
   static const String& RBracket() {
     return *(symbol_handles_[kNullCharId + ']']);
   }
   static const String& LBrace() {
     return *(symbol_handles_[kNullCharId + '{']);
   }
   static const String& RBrace() {
     return *(symbol_handles_[kNullCharId + '}']);
   }
-  static const String& Blank() {
-    return *(symbol_handles_[kNullCharId + ' ']);
-  }
+  static const String& Blank() { return *(symbol_handles_[kNullCharId + ' ']); }
   static const String& Dollar() {
     return *(symbol_handles_[kNullCharId + '$']);
   }
   static const String& NewLine() {
     return *(symbol_handles_[kNullCharId + '\n']);
   }
   static const String& DoubleQuote() {
     return *(symbol_handles_[kNullCharId + '"']);
   }
   static const String& SingleQuote() {
     return *(symbol_handles_[kNullCharId + '\'']);
   }
   static const String& LowercaseR() {
     return *(symbol_handles_[kNullCharId + 'r']);
   }
-  static const String& Dash() {
-    return *(symbol_handles_[kNullCharId + '-']);
-  }
+  static const String& Dash() { return *(symbol_handles_[kNullCharId + '-']); }
   static const String& Ampersand() {
     return *(symbol_handles_[kNullCharId + '&']);
   }
   static const String& Backtick() {
     return *(symbol_handles_[kNullCharId + '`']);
   }
-  static const String& Slash() {
-    return *(symbol_handles_[kNullCharId + '/']);
-  }
-  static const String& At() {
-    return *(symbol_handles_[kNullCharId + '@']);
-  }
+  static const String& Slash() { return *(symbol_handles_[kNullCharId + '/']); }
+  static const String& At() { return *(symbol_handles_[kNullCharId + '@']); }
   static const String& HashMark() {
     return *(symbol_handles_[kNullCharId + '#']);
   }
   static const String& Semicolon() {
     return *(symbol_handles_[kNullCharId + ';']);
   }
-  static const String& Star() {
-    return *(symbol_handles_[kNullCharId + '*']);
-  }
+  static const String& Star() { return *(symbol_handles_[kNullCharId + '*']); }
   static const String& Percent() {
     return *(symbol_handles_[kNullCharId + '%']);
   }
-  static const String& Caret() {
-    return *(symbol_handles_[kNullCharId + '^']);
-  }
-  static const String& Tilde() {
-    return *(symbol_handles_[kNullCharId + '~']);
-  }
+  static const String& Caret() { return *(symbol_handles_[kNullCharId + '^']); }
+  static const String& Tilde() { return *(symbol_handles_[kNullCharId + '~']); }
 
   static const String& Empty() { return *(symbol_handles_[kTokenTableStart]); }
   static const String& False() { return *(symbol_handles_[kFALSEId]); }
   static const String& Library() { return *(symbol_handles_[kLIBRARYId]); }
   static const String& Super() { return *(symbol_handles_[kSUPERId]); }
   static const String& This() { return *(symbol_handles_[kTHISId]); }
   static const String& True() { return *(symbol_handles_[kTRUEId]); }
   static const String& Void() { return *(symbol_handles_[kVOIDId]); }
 
-  // Access methods for symbol handles stored in the vm isolate for predefined
-  // symbols.
+// Access methods for symbol handles stored in the vm isolate for predefined
+// symbols.
 #define DEFINE_SYMBOL_HANDLE_ACCESSOR(symbol, literal)                         \
   static const String& symbol() { return *(symbol_handles_[k##symbol##Id]); }
   PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_HANDLE_ACCESSOR)
 #undef DEFINE_SYMBOL_HANDLE_ACCESSOR
 
-  // Access methods for symbol handles stored in the vm isolate for keywords.
+// Access methods for symbol handles stored in the vm isolate for keywords.
 #define DEFINE_SYMBOL_HANDLE_ACCESSOR(t, s, p, a)                              \
   static const String& t() { return *(symbol_handles_[t##Id]); }
   DART_TOKEN_LIST(DEFINE_SYMBOL_HANDLE_ACCESSOR)
   DART_KEYWORD_LIST(DEFINE_SYMBOL_HANDLE_ACCESSOR)
 #undef DEFINE_SYMBOL_HANDLE_ACCESSOR
 
   // Get symbol for scanner token.
   static const String& Token(Token::Kind token);
 
   // Initialize frequently used symbols in the vm isolate.
@@ skipping 47 matching lines @@
   static RawString* NewFormatted(Thread* thread, const char* format, ...)
       PRINTF_ATTRIBUTE(2, 3);
   static RawString* NewFormattedV(Thread* thread,
                                   const char* format,
                                   va_list args);
 
   static RawString* FromConcat(Thread* thread,
                                const String& str1,
                                const String& str2);
 
-  static RawString* FromConcatAll(Thread* thread,
+  static RawString* FromConcatAll(
+      Thread* thread,
       const GrowableHandlePtrArray<const String>& strs);
 
   static RawString* FromGet(Thread* thread, const String& str);
   static RawString* FromSet(Thread* thread, const String& str);
   static RawString* FromDot(Thread* thread, const String& str);
 
   // Returns char* of predefined symbol.
   static const char* Name(SymbolId symbol);
 
   static RawString* FromCharCode(Thread* thread, int32_t char_code);
 
   static RawString** PredefinedAddress() {
     return reinterpret_cast<RawString**>(&predefined_);
   }
 
   static void DumpStats();
 
   // Returns Symbol::Null if no symbol is found.
-  template<typename StringType>
+  template <typename StringType>
   static RawString* Lookup(Thread* thread, const StringType& str);
 
   // Returns Symbol::Null if no symbol is found.
   static RawString* LookupFromConcat(Thread* thread,
                                      const String& str1,
                                      const String& str2);
 
   static RawString* LookupFromGet(Thread* thread, const String& str);
   static RawString* LookupFromSet(Thread* thread, const String& str);
   static RawString* LookupFromDot(Thread* thread, const String& str);
 
-  static void GetStats(Isolate* isolate,
-                       intptr_t* size,
-                       intptr_t* capacity);
+  static void GetStats(Isolate* isolate, intptr_t* size, intptr_t* capacity);
 
  private:
-  enum {
-    kInitialVMIsolateSymtabSize = 1024,
-    kInitialSymtabSize = 2048
-  };
+  enum { kInitialVMIsolateSymtabSize = 1024, kInitialSymtabSize = 2048 };
 
-  template<typename StringType>
+  template <typename StringType>
   static RawString* NewSymbol(Thread* thread, const StringType& str);
 
   static intptr_t LookupPredefinedSymbol(RawObject* obj);
   static RawObject* GetPredefinedSymbol(intptr_t object_id);
   static bool IsPredefinedSymbolId(intptr_t object_id) {
     return (object_id >= kMaxPredefinedObjectIds &&
             object_id < (kMaxPredefinedObjectIds + kMaxPredefinedId));
   }
 
   // List of Latin1 characters stored in the vm isolate as symbols
@@ skipping 11 matching lines @@
   friend class Serializer;
   friend class Deserializer;
   friend class ApiMessageReader;
 
   DISALLOW_COPY_AND_ASSIGN(Symbols);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_SYMBOLS_H_