clang-format runtime/vm

runtime/vm/regexp_assembler_ir.h

 // Copyright (c) 2014, 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_REGEXP_ASSEMBLER_IR_H_
 #define RUNTIME_VM_REGEXP_ASSEMBLER_IR_H_
 
 #include "vm/assembler.h"
 #include "vm/intermediate_language.h"
 #include "vm/object.h"
@@ skipping 65 matching lines @@
                                      uint16_t to,
                                      BlockLabel* on_in_range);
   virtual void CheckCharacterNotInRange(uint16_t from,
                                         uint16_t to,
                                         BlockLabel* on_not_in_range);
   virtual void CheckBitInTable(const TypedData& table, BlockLabel* on_bit_set);
 
   // Checks whether the given offset from the current position is before
   // the end of the string.
   virtual void CheckPosition(intptr_t cp_offset, BlockLabel* on_outside_input);
-  virtual bool CheckSpecialCharacterClass(
-      uint16_t type, BlockLabel* on_no_match);
+  virtual bool CheckSpecialCharacterClass(uint16_t type,
+                                          BlockLabel* on_no_match);
   virtual void Fail();
   virtual void IfRegisterGE(intptr_t reg,
-                            intptr_t comparand, BlockLabel* if_ge);
+                            intptr_t comparand,
+                            BlockLabel* if_ge);
   virtual void IfRegisterLT(intptr_t reg,
-                            intptr_t comparand, BlockLabel* if_lt);
+                            intptr_t comparand,
+                            BlockLabel* if_lt);
   virtual void IfRegisterEqPos(intptr_t reg, BlockLabel* if_eq);
   virtual IrregexpImplementation Implementation();
   virtual void GoTo(BlockLabel* to);
   virtual void LoadCurrentCharacter(intptr_t cp_offset,
                                     BlockLabel* on_end_of_input,
                                     bool check_bounds = true,
                                     intptr_t characters = 1);
   virtual void PopCurrentPosition();
   virtual void PopRegister(intptr_t register_index);
   virtual void Print(const char* str);
@@ skipping 39 matching lines @@
     kNE,
     kLT,
     kGT,
     kLTE,
     kGTE,
   };
 
   struct InstanceCallDescriptor {
     // Standard (i.e. most non-Smi) functions.
     explicit InstanceCallDescriptor(const String& name)
-      : name(name),
-        token_kind(Token::kILLEGAL),
-        checked_argument_count(1) { }
+        : name(name), token_kind(Token::kILLEGAL), checked_argument_count(1) {}
 
     InstanceCallDescriptor(const String& name,
                            Token::Kind token_kind,
                            intptr_t checked_argument_count)
-      : name(name),
-        token_kind(token_kind),
-        checked_argument_count(checked_argument_count) { }
+        : name(name),
+          token_kind(token_kind),
+          checked_argument_count(checked_argument_count) {}
 
     // Special cases for Smi and indexing functions.
     static InstanceCallDescriptor FromToken(Token::Kind token_kind) {
       switch (token_kind) {
-        case Token::kEQ: return InstanceCallDescriptor(
-                  Symbols::EqualOperator(), token_kind, 2);
-        case Token::kADD: return InstanceCallDescriptor(
-                Symbols::Plus(), token_kind, 2);
-        case Token::kSUB: return InstanceCallDescriptor(
-                Symbols::Minus(), token_kind, 2);
-        case Token::kBIT_OR: return InstanceCallDescriptor(
-                Symbols::BitOr(), token_kind, 2);
-        case Token::kBIT_AND: return InstanceCallDescriptor(
-                Symbols::BitAnd(), token_kind, 2);
-        case Token::kLT: return InstanceCallDescriptor(
-                Symbols::LAngleBracket(), token_kind, 2);
-        case Token::kLTE: return InstanceCallDescriptor(
-                Symbols::LessEqualOperator(), token_kind, 2);
-        case Token::kGT: return InstanceCallDescriptor(
-                Symbols::RAngleBracket(), token_kind, 2);
-        case Token::kGTE: return InstanceCallDescriptor(
-                Symbols::GreaterEqualOperator(), token_kind, 2);
-        case Token::kNEGATE: return InstanceCallDescriptor(
-                Symbols::UnaryMinus(), token_kind, 1);
-        case Token::kINDEX: return InstanceCallDescriptor(
-                Symbols::IndexToken(), token_kind, 2);
-        case Token::kASSIGN_INDEX: return InstanceCallDescriptor(
-                Symbols::AssignIndexToken(), token_kind, 2);
+        case Token::kEQ:
+          return InstanceCallDescriptor(Symbols::EqualOperator(), token_kind,
+                                        2);
+        case Token::kADD:
+          return InstanceCallDescriptor(Symbols::Plus(), token_kind, 2);
+        case Token::kSUB:
+          return InstanceCallDescriptor(Symbols::Minus(), token_kind, 2);
+        case Token::kBIT_OR:
+          return InstanceCallDescriptor(Symbols::BitOr(), token_kind, 2);
+        case Token::kBIT_AND:
+          return InstanceCallDescriptor(Symbols::BitAnd(), token_kind, 2);
+        case Token::kLT:
+          return InstanceCallDescriptor(Symbols::LAngleBracket(), token_kind,
+                                        2);
+        case Token::kLTE:
+          return InstanceCallDescriptor(Symbols::LessEqualOperator(),
+                                        token_kind, 2);
+        case Token::kGT:
+          return InstanceCallDescriptor(Symbols::RAngleBracket(), token_kind,
+                                        2);
+        case Token::kGTE:
+          return InstanceCallDescriptor(Symbols::GreaterEqualOperator(),
+                                        token_kind, 2);
+        case Token::kNEGATE:
+          return InstanceCallDescriptor(Symbols::UnaryMinus(), token_kind, 1);
+        case Token::kINDEX:
+          return InstanceCallDescriptor(Symbols::IndexToken(), token_kind, 2);
+        case Token::kASSIGN_INDEX:
+          return InstanceCallDescriptor(Symbols::AssignIndexToken(), token_kind,
+                                        2);
         default:
           UNREACHABLE();
       }
       UNREACHABLE();
       return InstanceCallDescriptor(Symbols::Empty());
     }
 
     const String& name;
     Token::Kind token_kind;
     intptr_t checked_argument_count;
@@ skipping 87 matching lines @@
                          BlockLabel* true_successor);
 
   // Set up all local variables and parameters.
   void InitializeLocals();
 
   // Allocates a new local, and returns the appropriate id for placing it
   // on the stack.
   intptr_t GetNextLocalIndex();
 
   // We never have any copied parameters.
-  intptr_t num_copied_params() const {
-    return 0;
-  }
+  intptr_t num_copied_params() const { return 0; }
 
   // Return the position register at the specified index, creating it if
   // necessary. Note that the number of such registers can exceed the amount
   // required by the number of output captures.
   LocalVariable* position_register(intptr_t index);
 
   void set_current_instruction(Instruction* instruction);
 
   // The following functions are responsible for appending instructions
   // to the current instruction in various ways. The most simple one
@@ skipping 19 matching lines @@
   Definition* PeekStack();
   void CheckStackLimit();
   void GrowStack();
 
   // Prints the specified argument. Used for debugging.
   void Print(PushArgumentInstr* argument);
 
   // A utility class tracking ids of various objects such as blocks, temps, etc.
   class IdAllocator : public ValueObject {
    public:
-    IdAllocator() : next_id(0) { }
+    IdAllocator() : next_id(0) {}
 
     intptr_t Count() const { return next_id; }
     intptr_t Alloc(intptr_t count = 1) {
       ASSERT(count >= 0);
       intptr_t current_id = next_id;
       next_id += count;
       return current_id;
     }
     void Dealloc(intptr_t count = 1) {
       ASSERT(count <= next_id);
@@ skipping 76 matching lines @@
   IdAllocator temp_id_;
   IdAllocator arg_id_;
   IdAllocator local_id_;
   IdAllocator indirect_id_;
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_REGEXP_ASSEMBLER_IR_H_