clang-format runtime/vm

runtime/vm/regexp_assembler_bytecode.cc

 // Copyright (c) 2015, 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.
 
 #include "vm/regexp_assembler_bytecode.h"
 
 #include "vm/regexp_assembler_bytecode_inl.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/regexp_bytecodes.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp.h"
 #include "vm/regexp_parser.h"
 #include "vm/regexp_interpreter.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
 BytecodeRegExpMacroAssembler::BytecodeRegExpMacroAssembler(
     ZoneGrowableArray<uint8_t>* buffer,
     Zone* zone)
     : RegExpMacroAssembler(zone),
       buffer_(buffer),
       pc_(0),
-      advance_current_end_(kInvalidPC) { }
+      advance_current_end_(kInvalidPC) {}
 
 
 BytecodeRegExpMacroAssembler::~BytecodeRegExpMacroAssembler() {
   if (backtrack_.is_linked()) backtrack_.Unuse();
 }
 
 
 BytecodeRegExpMacroAssembler::IrregexpImplementation
 BytecodeRegExpMacroAssembler::Implementation() {
   return kBytecodeImplementation;
@@ skipping 38 matching lines @@
 
 
 void BytecodeRegExpMacroAssembler::PushRegister(intptr_t register_index) {
   ASSERT(register_index >= 0);
   ASSERT(register_index <= kMaxRegister);
   Emit(BC_PUSH_REGISTER, register_index);
 }
 
 
 void BytecodeRegExpMacroAssembler::WriteCurrentPositionToRegister(
-    intptr_t register_index, intptr_t cp_offset) {
+    intptr_t register_index,
+    intptr_t cp_offset) {
   ASSERT(register_index >= 0);
   ASSERT(register_index <= kMaxRegister);
   Emit(BC_SET_REGISTER_TO_CP, register_index);
   Emit32(cp_offset);  // Current position offset.
 }
 
 
 void BytecodeRegExpMacroAssembler::ClearRegisters(intptr_t reg_from,
                                                   intptr_t reg_to) {
   ASSERT(reg_from <= reg_to);
@@ skipping 102 matching lines @@
   ASSERT(by >= kMinCPOffset);
   ASSERT(by <= kMaxCPOffset);
   advance_current_start_ = pc_;
   advance_current_offset_ = by;
   Emit(BC_ADVANCE_CP, by);
   advance_current_end_ = pc_;
 }
 
 
 void BytecodeRegExpMacroAssembler::CheckGreedyLoop(
-      BlockLabel* on_tos_equals_current_position) {
+    BlockLabel* on_tos_equals_current_position) {
   Emit(BC_CHECK_GREEDY, 0);
   EmitOrLink(on_tos_equals_current_position);
 }
 
 
 void BytecodeRegExpMacroAssembler::LoadCurrentCharacter(intptr_t cp_offset,
                                                         BlockLabel* on_failure,
                                                         bool check_bounds,
                                                         intptr_t characters) {
   ASSERT(cp_offset >= kMinCPOffset);
@@ skipping 131 matching lines @@
     uint16_t from,
     uint16_t to,
     BlockLabel* on_not_in_range) {
   Emit(BC_CHECK_CHAR_NOT_IN_RANGE, 0);
   Emit16(from);
   Emit16(to);
   EmitOrLink(on_not_in_range);
 }
 
 
-void BytecodeRegExpMacroAssembler::CheckBitInTable(
-    const TypedData& table, BlockLabel* on_bit_set) {
+void BytecodeRegExpMacroAssembler::CheckBitInTable(const TypedData& table,
+                                                   BlockLabel* on_bit_set) {
   Emit(BC_CHECK_BIT_IN_TABLE, 0);
   EmitOrLink(on_bit_set);
   for (int i = 0; i < kTableSize; i += kBitsPerByte) {
     int byte = 0;
     for (int j = 0; j < kBitsPerByte; j++) {
       if (table.GetUint8(i + j) != 0) byte |= 1 << j;
     }
     Emit8(byte);
   }
 }
@@ skipping 71 matching lines @@
 }
 
 
 void BytecodeRegExpMacroAssembler::Expand() {
   // BOGUS
   buffer_->Add(0);
   buffer_->Add(0);
   buffer_->Add(0);
   buffer_->Add(0);
   intptr_t x = buffer_->length();
-  for (intptr_t i = 0; i < x; i++) buffer_->Add(0);
+  for (intptr_t i = 0; i < x; i++)
+    buffer_->Add(0);
 }
 
 
 static intptr_t Prepare(const RegExp& regexp,
                         const String& subject,
                         Zone* zone) {
-  bool is_one_byte = subject.IsOneByteString() ||
-                     subject.IsExternalOneByteString();
+  bool is_one_byte =
+      subject.IsOneByteString() || subject.IsExternalOneByteString();
 
   if (regexp.bytecode(is_one_byte) == TypedData::null()) {
     const String& pattern = String::Handle(zone, regexp.pattern());
-    NOT_IN_PRODUCT(TimelineDurationScope tds(Thread::Current(),
-                                             Timeline::GetCompilerStream(),
-                                             "CompileIrregexpBytecode");
+#if !defined(PRODUCT)
+    TimelineDurationScope tds(Thread::Current(), Timeline::GetCompilerStream(),
+                              "CompileIrregexpBytecode");
     if (tds.enabled()) {
       tds.SetNumArguments(1);
       tds.CopyArgument(0, "pattern", pattern.ToCString());
-    });  // !PRODUCT
+    }
+#endif  // !defined(PRODUCT)
 
     const bool multiline = regexp.is_multi_line();
-    RegExpCompileData* compile_data = new(zone) RegExpCompileData();
+    RegExpCompileData* compile_data = new (zone) RegExpCompileData();
     if (!RegExpParser::ParseRegExp(pattern, multiline, compile_data)) {
       // Parsing failures are handled in the RegExp factory constructor.
       UNREACHABLE();
     }
 
     regexp.set_num_bracket_expressions(compile_data->capture_count);
     if (compile_data->simple) {
       regexp.set_is_simple();
     } else {
       regexp.set_is_complex();
@@ skipping 14 matching lines @@
          (Smi::Value(regexp.num_bracket_expressions()) + 1) * 2;
 }
 
 
 static IrregexpInterpreter::IrregexpResult ExecRaw(const RegExp& regexp,
                                                    const String& subject,
                                                    intptr_t index,
                                                    int32_t* output,
                                                    intptr_t output_size,
                                                    Zone* zone) {
-  bool is_one_byte = subject.IsOneByteString() ||
-                     subject.IsExternalOneByteString();
+  bool is_one_byte =
+      subject.IsOneByteString() || subject.IsExternalOneByteString();
 
   ASSERT(regexp.num_bracket_expressions() != Smi::null());
 
   // We must have done EnsureCompiledIrregexp, so we can get the number of
   // registers.
   int number_of_capture_registers =
-     (Smi::Value(regexp.num_bracket_expressions()) + 1) * 2;
+      (Smi::Value(regexp.num_bracket_expressions()) + 1) * 2;
   int32_t* raw_output = &output[number_of_capture_registers];
 
   // We do not touch the actual capture result registers until we know there
   // has been a match so that we can use those capture results to set the
   // last match info.
   for (int i = number_of_capture_registers - 1; i >= 0; i--) {
     raw_output[i] = -1;
   }
 
   const TypedData& bytecode =
@@ skipping 24 matching lines @@
                                                      Zone* zone) {
   intptr_t required_registers = Prepare(regexp, subject, zone);
   if (required_registers < 0) {
     // Compiling failed with an exception.
     UNREACHABLE();
   }
 
   // V8 uses a shared copy on the isolate when smaller than some threshold.
   int32_t* output_registers = zone->Alloc<int32_t>(required_registers);
 
-  IrregexpInterpreter::IrregexpResult result = ExecRaw(regexp,
-                                                       subject,
-                                                       start_index.Value(),
-                                                       output_registers,
-                                                       required_registers,
-                                                       zone);
+  IrregexpInterpreter::IrregexpResult result =
+      ExecRaw(regexp, subject, start_index.Value(), output_registers,
+              required_registers, zone);
 
   if (result == IrregexpInterpreter::RE_SUCCESS) {
     intptr_t capture_count = Smi::Value(regexp.num_bracket_expressions());
     intptr_t capture_register_count = (capture_count + 1) * 2;
     ASSERT(required_registers >= capture_register_count);
 
-    const TypedData& result =
-        TypedData::Handle(TypedData::New(kTypedDataInt32ArrayCid,
-                                         capture_register_count));
+    const TypedData& result = TypedData::Handle(
+        TypedData::New(kTypedDataInt32ArrayCid, capture_register_count));
     {
 #ifdef DEBUG
       // These indices will be used with substring operations that don't check
       // bounds, so sanity check them here.
       for (intptr_t i = 0; i < capture_register_count; i++) {
         int32_t val = output_registers[i];
         ASSERT(val == -1 || (val >= 0 && val <= subject.Length()));
       }
 #endif
 
       NoSafepointScope no_safepoint;
-      memmove(result.DataAddr(0),
-              output_registers,
+      memmove(result.DataAddr(0), output_registers,
               capture_register_count * sizeof(int32_t));
     }
 
     return result.raw();
   }
   if (result == IrregexpInterpreter::RE_EXCEPTION) {
     UNREACHABLE();
   }
   ASSERT(result == IrregexpInterpreter::RE_FAILURE);
   return Instance::null();
 }
 
 
 }  // namespace dart