clang-format runtime/vm

runtime/vm/json_stream.cc

 // Copyright (c) 2013, 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 "platform/assert.h"
 
 #include "include/dart_native_api.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/json_stream.h"
@@ skipping 47 matching lines @@
       count_(-1) {
   ObjectIdRing* ring = NULL;
   Isolate* isolate = Isolate::Current();
   if (isolate != NULL) {
     ring = isolate->object_id_ring();
   }
   default_id_zone_.Init(ring, ObjectIdRing::kAllocateId);
 }
 
 
-JSONStream::~JSONStream() {
-}
+JSONStream::~JSONStream() {}
 
 
 void JSONStream::Setup(Zone* zone,
                        Dart_Port reply_port,
                        const Instance& seq,
                        const String& method,
                        const Array& param_keys,
                        const Array& param_values,
                        bool parameters_are_dart_objects) {
   set_reply_port(reply_port);
@@ skipping 81 matching lines @@
   jsobj.AddProperty("method", js->method());
   {
     JSONObject params(&jsobj, "params");
     for (intptr_t i = 0; i < js->num_params(); i++) {
       params.AddProperty(js->GetParamKey(i), js->GetParamValue(i));
     }
   }
 }
 
 
-void JSONStream::PrintError(intptr_t code,
-                            const char* details_format, ...) {
+void JSONStream::PrintError(intptr_t code, const char* details_format, ...) {
   SetupError();
   JSONObject jsobj(this);
   jsobj.AddProperty("code", code);
   jsobj.AddProperty("message", GetJSONRpcErrorMessage(code));
   {
     JSONObject data(&jsobj, "data");
     PrintRequest(&data, this);
     if (details_format != NULL) {
       va_list args;
       va_start(args, details_format);
       intptr_t len = OS::VSNPrint(NULL, 0, details_format, args);
       va_end(args);
 
       char* buffer = Thread::Current()->zone()->Alloc<char>(len + 1);
       va_list args2;
       va_start(args2, details_format);
       OS::VSNPrint(buffer, (len + 1), details_format, args2);
       va_end(args2);
 
       data.AddProperty("details", buffer);
     }
   }
 }
 
 
 void JSONStream::PostNullReply(Dart_Port port) {
-  PortMap::PostMessage(new Message(
-      port, Object::null(), Message::kNormalPriority));
+  PortMap::PostMessage(
+      new Message(port, Object::null(), Message::kNormalPriority));
 }
 
 
 static void Finalizer(void* isolate_callback_data,
                       Dart_WeakPersistentHandle handle,
                       void* buffer) {
   free(buffer);
 }
 
 
@@ skipping 44 matching lines @@
   if (!result) {
     free(cstr);
   }
 
   if (FLAG_trace_service) {
     Isolate* isolate = Isolate::Current();
     ASSERT(isolate != NULL);
     const char* isolate_name = isolate->name();
     int64_t total_time = OS::GetCurrentTimeMicros() - setup_time_micros_;
     if (result) {
-      OS::Print("[+%" Pd64 "ms] Isolate %s processed service request %s "
+      OS::Print("[+%" Pd64
+                "ms] Isolate %s processed service request %s "
                 "(%" Pd64 "us)\n",
                 Dart::timestamp(), isolate_name, method_, total_time);
     } else {
-      OS::Print("[+%" Pd64 "ms] Isolate %s processed service request %s "
+      OS::Print("[+%" Pd64
+                "ms] Isolate %s processed service request %s "
                 "(%" Pd64 "us) FAILED\n",
                 Dart::timestamp(), isolate_name, method_, total_time);
     }
   }
 }
 
 
 const char* JSONStream::LookupParam(const char* key) const {
   for (int i = 0; i < num_params(); i++) {
     if (!strcmp(key, param_keys_[i])) {
@@ skipping 130 matching lines @@
 }
 
 
 void JSONStream::PrintValue(double d) {
   PrintCommaIfNeeded();
   buffer_.Printf("%f", d);
 }
 
 
 static const char base64_digits[65] =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static const char base64_pad = '=';
 
 
 void JSONStream::PrintValueBase64(const uint8_t* bytes, intptr_t length) {
   PrintCommaIfNeeded();
   buffer_.AddChar('"');
 
   intptr_t odd_bits = length % 3;
   intptr_t even_bits = length - odd_bits;
   for (intptr_t i = 0; i < even_bits; i += 3) {
@@ skipping 46 matching lines @@
 }
 
 
 void JSONStream::PrintfValue(const char* format, ...) {
   PrintCommaIfNeeded();
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
-  char* p = reinterpret_cast<char*>(malloc(len+1));
+  char* p = reinterpret_cast<char*>(malloc(len + 1));
   va_start(args, format);
-  intptr_t len2 = OS::VSNPrint(p, len+1, format, args);
+  intptr_t len2 = OS::VSNPrint(p, len + 1, format, args);
   va_end(args);
   ASSERT(len == len2);
   buffer_.AddChar('"');
   AddEscapedUTF8String(p);
   buffer_.AddChar('"');
   free(p);
 }
 
 
 void JSONStream::PrintValue(const Object& o, bool ref) {
@@ skipping 174 matching lines @@
   PrintValue(timeline_event_block);
 }
 
 
 void JSONStream::PrintfProperty(const char* name, const char* format, ...) {
   PrintPropertyName(name);
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
-  char* p = reinterpret_cast<char*>(malloc(len+1));
+  char* p = reinterpret_cast<char*>(malloc(len + 1));
   va_start(args, format);
-  intptr_t len2 = OS::VSNPrint(p, len+1, format, args);
+  intptr_t len2 = OS::VSNPrint(p, len + 1, format, args);
   va_end(args);
   ASSERT(len == len2);
   buffer_.AddChar('"');
   AddEscapedUTF8String(p);
   buffer_.AddChar('"');
   free(p);
 }
 
 
 void JSONStream::Steal(char** buffer, intptr_t* buffer_length) {
@@ skipping 82 matching lines @@
   }
 }
 
 
 bool JSONStream::NeedComma() {
   const char* buffer = buffer_.buf();
   intptr_t length = buffer_.length();
   if (length == 0) {
     return false;
   }
-  char ch = buffer[length-1];
+  char ch = buffer[length - 1];
   return (ch != '[') && (ch != '{') && (ch != ':') && (ch != ',');
 }
 
 
 void JSONStream::EnsureIntegerIsRepresentableInJavaScript(int64_t i) {
 #ifdef DEBUG
   if (!Utils::IsJavascriptInt(i)) {
-    OS::Print("JSONStream::EnsureIntegerIsRepresentableInJavaScript failed on "
-              "%" Pd64 "\n", i);
+    OS::Print(
+        "JSONStream::EnsureIntegerIsRepresentableInJavaScript failed on "
+        "%" Pd64 "\n",
+        i);
     UNREACHABLE();
   }
 #endif
 }
 
 
 void JSONStream::AddEscapedUTF8String(const char* s) {
   if (s == NULL) {
     return;
   }
   intptr_t len = strlen(s);
   AddEscapedUTF8String(s, len);
 }
 
 
 void JSONStream::AddEscapedUTF8String(const char* s, intptr_t len) {
   if (s == NULL) {
     return;
   }
   const uint8_t* s8 = reinterpret_cast<const uint8_t*>(s);
   intptr_t i = 0;
-  for (; i < len; ) {
+  for (; i < len;) {
     // Extract next UTF8 character.
     int32_t ch = 0;
     int32_t ch_len = Utf8::Decode(&s8[i], len - i, &ch);
     ASSERT(ch_len != 0);
     buffer_.EscapeAndAddCodeUnit(ch);
     // Move i forward.
     i += ch_len;
   }
   ASSERT(i == len);
 }
@@ skipping 12 matching lines @@
   }
   intptr_t limit = offset + count;
   for (intptr_t i = offset; i < limit; i++) {
     uint16_t code_unit = s.CharAt(i);
     if (Utf16::IsTrailSurrogate(code_unit)) {
       buffer_.EscapeAndAddUTF16CodeUnit(code_unit);
     } else if (Utf16::IsLeadSurrogate(code_unit)) {
       if (i + 1 == limit) {
         buffer_.EscapeAndAddUTF16CodeUnit(code_unit);
       } else {
-        uint16_t next_code_unit = s.CharAt(i+1);
+        uint16_t next_code_unit = s.CharAt(i + 1);
         if (Utf16::IsTrailSurrogate(next_code_unit)) {
           uint32_t decoded = Utf16::Decode(code_unit, next_code_unit);
           buffer_.EscapeAndAddCodeUnit(decoded);
           i++;
         } else {
           buffer_.EscapeAndAddUTF16CodeUnit(code_unit);
         }
       }
     } else {
       buffer_.EscapeAndAddCodeUnit(code_unit);
@@ skipping 11 matching lines @@
 
 void JSONObject::AddFixedServiceId(const char* format, ...) const {
   // Mark that this id is fixed.
   AddProperty("fixedId", true);
   // Add the id property.
   stream_->PrintPropertyName("id");
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
-  char* p = reinterpret_cast<char*>(malloc(len+1));
+  char* p = reinterpret_cast<char*>(malloc(len + 1));
   va_start(args, format);
-  intptr_t len2 = OS::VSNPrint(p, len+1, format, args);
+  intptr_t len2 = OS::VSNPrint(p, len + 1, format, args);
   va_end(args);
   ASSERT(len == len2);
   stream_->buffer_.AddChar('"');
   stream_->AddEscapedUTF8String(p);
   stream_->buffer_.AddChar('"');
   free(p);
 }
 
 
 void JSONObject::AddLocation(const Script& script,
@@ skipping 36 matching lines @@
   if (!script.IsNull()) {
     location.AddProperty("script", script);
   } else {
     const String& scriptUri = String::Handle(zone, bpt_loc->url());
     location.AddPropertyStr("scriptUri", scriptUri);
   }
   if (bpt_loc->requested_line_number() >= 0) {
     // This unresolved breakpoint was specified at a particular line.
     location.AddProperty("line", bpt_loc->requested_line_number());
     if (bpt_loc->requested_column_number() >= 0) {
-      location.AddProperty("column",
-                           bpt_loc->requested_column_number());
+      location.AddProperty("column", bpt_loc->requested_column_number());
     }
   } else {
     // This unresolved breakpoint was requested at some function entry.
     location.AddProperty("tokenPos", token_pos);
   }
 }
 
 
-void JSONObject::AddPropertyF(const char* name,
-                              const char* format, ...) const {
+void JSONObject::AddPropertyF(const char* name, const char* format, ...) const {
   stream_->PrintPropertyName(name);
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
-  char* p = reinterpret_cast<char*>(malloc(len+1));
+  char* p = reinterpret_cast<char*>(malloc(len + 1));
   va_start(args, format);
-  intptr_t len2 = OS::VSNPrint(p, len+1, format, args);
+  intptr_t len2 = OS::VSNPrint(p, len + 1, format, args);
   va_end(args);
   ASSERT(len == len2);
   stream_->buffer_.AddChar('"');
   stream_->AddEscapedUTF8String(p);
   stream_->buffer_.AddChar('"');
   free(p);
 }
 
 
 void JSONArray::AddValueF(const char* format, ...) const {
   stream_->PrintCommaIfNeeded();
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
-  char* p = reinterpret_cast<char*>(malloc(len+1));
+  char* p = reinterpret_cast<char*>(malloc(len + 1));
   va_start(args, format);
-  intptr_t len2 = OS::VSNPrint(p, len+1, format, args);
+  intptr_t len2 = OS::VSNPrint(p, len + 1, format, args);
   va_end(args);
   ASSERT(len == len2);
   stream_->buffer_.AddChar('"');
   stream_->AddEscapedUTF8String(p);
   stream_->buffer_.AddChar('"');
   free(p);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart