Uses SNPRINT macro where possible. Otherwise uses #define for format.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 4220 matching lines @@
   const Library& lib = Library::Handle(isolate, library());
   const Object& obj = Object::Handle(isolate, lib.LookupLocalObject(name));
   if (!obj.IsNull() && obj.IsLibraryPrefix()) {
     return LibraryPrefix::Cast(obj).raw();
   }
   return LibraryPrefix::null();
 }
 
 
 const char* Class::ToCString() const {
-  const char* format = "%s %sClass: %s";
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* patch_prefix = is_patch() ? "Patch " : "";
   const char* class_name = String::Handle(Name()).ToCString();
-  intptr_t len =
-      OS::SNPrint(NULL, 0, format, library_name, patch_prefix, class_name) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, library_name, patch_prefix, class_name);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "%s %sClass: %s",
+          library_name, patch_prefix, class_name);
   return chars;
 }
 
 
 void Class::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Isolate* isolate = Isolate::Current();
   JSONObject jsobj(stream);
   if ((raw() == Class::null()) || (id() == kFreeListElement)) {
     // TODO(turnidge): This is weird and needs to be changed.
     jsobj.AddProperty("type", "null");
@@ skipping 148 matching lines @@
     const String& str = String::Handle(ident());
     name = String::Concat(name, str);
     return name.raw();
   } else {
     return ident();
   }
 }
 
 
 const char* UnresolvedClass::ToCString() const {
-  const char* format = "unresolved class '%s'";
+  char *chars = NULL;
   const char* cname =  String::Handle(Name()).ToCString();
-  intptr_t len = OS::SNPrint(NULL, 0, format, cname) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, cname);
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+          "unresolved class '%s'", cname);
   return chars;
 }
 
 
 void UnresolvedClass::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 static uint32_t CombineHashes(uint32_t hash, uint32_t other_hash) {
@@ skipping 727 matching lines @@
   ASSERT(result.IsTypeArguments());
   ASSERT(result.IsCanonical());
   return result.raw();
 }
 
 
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL TypeArguments";
   }
-  const char* format = "%s [%s]";
   const char* prev_cstr = "TypeArguments:";
   for (int i = 0; i < Length(); i++) {
     const AbstractType& type_at = AbstractType::Handle(TypeAt(i));
     const char* type_cstr = type_at.IsNull() ? "null" : type_at.ToCString();
-    intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, prev_cstr, type_cstr);
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "%s [%s]",
+            prev_cstr, type_cstr);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 const char* PatchClass::ToCString() const {
-  const char* kFormat = "PatchClass for %s";
   const Class& cls = Class::Handle(patched_class());
   const char* cls_name = cls.ToCString();
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, cls_name) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, cls_name);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "PatchClass for %s",
+          cls_name);
   return chars;
 }
 
 
 void PatchClass::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 RawPatchClass* PatchClass::New(const Class& patched_class,
@@ skipping 1814 matching lines @@
       break;
     case RawFunction::kInvokeFieldDispatcher:
       kind_str = "invoke-field-dispatcher";
       break;
     case RawFunction::kIrregexpFunction:
       kind_str = "irregexp-function";
       break;
     default:
       UNREACHABLE();
   }
-  const char* kFormat = "Function '%s':%s%s%s%s.";
   const char* function_name = String::Handle(name()).ToCString();
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name,
-                             static_str, abstract_str, kind_str, const_str) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, function_name,
-              static_str, abstract_str, kind_str, const_str);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+          "Function '%s':%s%s%s%s.",
+          function_name, static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
 static void AddFunctionServiceId(const JSONObject& jsobj,
                                  const Function& f,
                                  const Class& cls) {
   // Special kinds of functions use indices in their respective lists.
   intptr_t id = -1;
   const char* selector = NULL;
@@ skipping 360 matching lines @@
 }
 
 
 const char* Field::ToCString() const {
   if (IsNull()) {
     return "Field::null";
   }
   const char* kF0 = is_static() ? " static" : "";
   const char* kF1 = is_final() ? " final" : "";
   const char* kF2 = is_const() ? " const" : "";
-  const char* kFormat = "Field <%s.%s>:%s%s%s";
   const char* field_name = String::Handle(name()).ToCString();
   const Class& cls = Class::Handle(owner());
   const char* cls_name = String::Handle(cls.Name()).ToCString();
-  intptr_t len =
-      OS::SNPrint(NULL, 0, kFormat, cls_name, field_name, kF0, kF1, kF2) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, cls_name, field_name, kF0, kF1, kF2);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "Field <%s.%s>:%s%s%s",
+          cls_name, field_name, kF0, kF1, kF2);
   return chars;
 }
 
 void Field::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   Class& cls = Class::Handle(owner());
   intptr_t id = cls.FindFieldIndex(*this);
   ASSERT(id >= 0);
   intptr_t cid = cls.id();
   AddCommonObjectProperties(&jsobj, "Field", ref);
@@ skipping 2761 matching lines @@
   return Isolate::Current()->object_store()->profiler_library();
 }
 
 
 RawLibrary* Library::TypedDataLibrary() {
   return Isolate::Current()->object_store()->typed_data_library();
 }
 
 
 const char* Library::ToCString() const {
-  const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, name.ToCString());
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "Library:'%s'",
+          name.ToCString());
   return chars;
 }
 
 
 void Library::PrintJSONImpl(JSONStream* stream, bool ref) const {
   intptr_t id = index();
   ASSERT(id >= 0);
   JSONObject jsobj(stream);
   AddCommonObjectProperties(&jsobj, "Library", ref);
   jsobj.AddFixedServiceId("libraries/%" Pd "", id);
@@ skipping 391 matching lines @@
   StoreNonPointer(&raw_ptr()->num_imports_, value);
 }
 
 
 void LibraryPrefix::set_importer(const Library& value) const {
   StorePointer(&raw_ptr()->importer_, value.raw());
 }
 
 
 const char* LibraryPrefix::ToCString() const {
-  const char* kFormat = "LibraryPrefix:'%s'";
   const String& prefix = String::Handle(name());
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, prefix.ToCString()) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, prefix.ToCString());
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "LibraryPrefix:'%s'",
+          prefix.ToCString());
   return chars;
 }
 
 
 void LibraryPrefix::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 void Namespace::set_metadata_field(const Field& value) const {
@@ skipping 31 matching lines @@
     if (metadata.IsArray()) {
       ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());
       field.SetStaticValue(Array::Cast(metadata), true);
     }
   }
   return metadata.raw();
 }
 
 
 const char* Namespace::ToCString() const {
-  const char* kFormat = "Namespace for library '%s'";
   const Library& lib = Library::Handle(library());
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, lib.ToCString()) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, lib.ToCString());
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+          "Namespace for library '%s'", lib.ToCString());
   return chars;
 }
 
 
 void Namespace::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 bool Namespace::HidesName(const String& name) const {
@@ skipping 494 matching lines @@
   // 4 bits per hex digit + 2 for "0x".
   const int addr_width = (kBitsPerWord / 4) + 2;
   // "*" in a printf format specifier tells it to read the field width from
   // the printf argument list.
   ISL_Print("%-*s\tkind    \tdeopt-id\ttok-ix\ttry-ix\n",
             addr_width, "pc");
 }
 
 
 const char* PcDescriptors::ToCString() const {
+  // "*" in a printf format specifier tells it to read the field width from
+  // the printf argument list.
+#define FORMAT "%#-*" Px "\t%s\t%" Pd "\t\t%" Pd "\t%" Pd "\n"
   if (Length() == 0) {
     return "empty PcDescriptors\n";
   }
   // 4 bits per hex digit.
   const int addr_width = kBitsPerWord / 4;
-  // "*" in a printf format specifier tells it to read the field width from
-  // the printf argument list.
-  const char* kFormat =
-      "%#-*" Px "\t%s\t%" Pd "\t\t%" Pd "\t%" Pd "\n";
   // First compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   {
     Iterator iter(*this, RawPcDescriptors::kAnyKind);
     while (iter.MoveNext()) {
-      len += OS::SNPrint(NULL, 0, kFormat, addr_width,
+      len += OS::SNPrint(NULL, 0, FORMAT, addr_width,
                          iter.PcOffset(),
                          KindAsStr(iter.Kind()),
                          iter.DeoptId(),
                          iter.TokenPos(),
                          iter.TryIndex());
     }
   }
   // Allocate the buffer.
   char* buffer = Thread::Current()->zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.MoveNext()) {
-    index += OS::SNPrint((buffer + index), (len - index), kFormat, addr_width,
+    index += OS::SNPrint((buffer + index), (len - index), FORMAT, addr_width,
                          iter.PcOffset(),
                          KindAsStr(iter.Kind()),
                          iter.DeoptId(),
                          iter.TokenPos(),
                          iter.TryIndex());
   }
   return buffer;
+#undef FORMAT
 }
 
 
 void PcDescriptors::PrintToJSONObject(JSONObject* jsobj, bool ref) const {
   AddCommonObjectProperties(jsobj, "Object", ref);
   // TODO(johnmccutchan): Generate a stable id. PcDescriptors hang off a Code
   // object but do not have a back reference to generate an ID.
   jsobj->AddServiceId(*this);
   if (ref) {
     return;
@@ skipping 150 matching lines @@
   // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
   result.SetPcOffset(pc_offset);
   result.SetRegisterBitCount(register_bit_count);
   return result.raw();
 }
 
 
 const char* Stackmap::ToCString() const {
+#define FORMAT "%#" Px ": "
   if (IsNull()) {
     return "{null}";
   } else {
-    const char* kFormat = "%#" Px ": ";
-    intptr_t fixed_length = OS::SNPrint(NULL, 0, kFormat, PcOffset()) + 1;
+    intptr_t fixed_length = OS::SNPrint(NULL, 0, FORMAT, PcOffset()) + 1;
     Thread* thread = Thread::Current();
     // Guard against integer overflow in the computation of alloc_size.
     //
     // TODO(kmillikin): We could just truncate the string if someone
     // tries to print a 2 billion plus entry stackmap.
     if (Length() > (kIntptrMax - fixed_length)) {
       FATAL1("Length() is unexpectedly large (%" Pd ")", Length());
     }
     intptr_t alloc_size = fixed_length + Length();
     char* chars = thread->zone()->Alloc<char>(alloc_size);
-    intptr_t index = OS::SNPrint(chars, alloc_size, kFormat, PcOffset());
+    intptr_t index = OS::SNPrint(chars, alloc_size, FORMAT, PcOffset());
     for (intptr_t i = 0; i < Length(); i++) {
       chars[index++] = IsObject(i) ? '1' : '0';
     }
     chars[index] = '\0';
     return chars;
   }
+#undef FORMAT
 }
 
 
 void Stackmap::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
   ASSERT(var_index < Length());
@@ skipping 310 matching lines @@
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_handlers);
   }
   result.set_handled_types_data(handled_types_data);
   return result.raw();
 }
 
 
 const char* ExceptionHandlers::ToCString() const {
+#define FORMAT1 "%" Pd " => %#" Px "  (%" Pd " types) (outer %" Pd ")\n"
+#define FORMAT2 "  %d. %s\n"
   if (num_entries() == 0) {
     return "empty ExceptionHandlers\n";
   }
   Array& handled_types = Array::Handle();
   Type& type = Type::Handle();
   RawExceptionHandlers::HandlerInfo info;
   // First compute the buffer size required.
-  const char* kFormat = "%" Pd " => %#" Px "  (%" Pd
-                        " types) (outer %" Pd ")\n";
-  const char* kFormat2 = "  %d. %s\n";
   intptr_t len = 1;  // Trailing '\0'.
   for (intptr_t i = 0; i < num_entries(); i++) {
     GetHandlerInfo(i, &info);
     handled_types = GetHandledTypes(i);
     const intptr_t num_types =
         handled_types.IsNull() ? 0 : handled_types.Length();
-    len += OS::SNPrint(NULL, 0, kFormat,
+    len += OS::SNPrint(NULL, 0, FORMAT1,
                        i,
                        info.handler_pc_offset,
                        num_types,
                        info.outer_try_index);
     for (int k = 0; k < num_types; k++) {
       type ^= handled_types.At(k);
       ASSERT(!type.IsNull());
-      len += OS::SNPrint(NULL, 0, kFormat2, k, type.ToCString());
+      len += OS::SNPrint(NULL, 0, FORMAT2, k, type.ToCString());
     }
   }
   // Allocate the buffer.
   char* buffer = Thread::Current()->zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t num_chars = 0;
   for (intptr_t i = 0; i < num_entries(); i++) {
     GetHandlerInfo(i, &info);
     handled_types = GetHandledTypes(i);
     const intptr_t num_types =
         handled_types.IsNull() ? 0 : handled_types.Length();
     num_chars += OS::SNPrint((buffer + num_chars),
                              (len - num_chars),
-                             kFormat,
+                             FORMAT1,
                              i,
                              info.handler_pc_offset,
                              num_types,
                              info.outer_try_index);
     for (int k = 0; k < num_types; k++) {
       type ^= handled_types.At(k);
       num_chars += OS::SNPrint((buffer + num_chars),
                                (len - num_chars),
-                               kFormat2, k, type.ToCString());
+                               FORMAT2, k, type.ToCString());
     }
   }
   return buffer;
+#undef FORMAT1
+#undef FORMAT2
 }
 
 
 void ExceptionHandlers::PrintJSONImpl(JSONStream* stream,
                                       bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 intptr_t DeoptInfo::FrameSize(const TypedData& packed) {
@@ skipping 56 matching lines @@
   // Pass kMaxInt32 as the length to unpack all instructions from the
   // packed stream.
   UnpackInto(table, packed, unpacked, kMaxInt32);
 
   unpacked->Reverse();
 }
 
 
 const char* DeoptInfo::ToCString(const Array& deopt_table,
                                  const TypedData& packed) {
+#define FORMAT "[%s]"
   GrowableArray<DeoptInstr*> deopt_instrs;
   Unpack(deopt_table, packed, &deopt_instrs);
 
   // Compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   for (intptr_t i = 0; i < deopt_instrs.length(); i++) {
-    len += OS::SNPrint(NULL, 0, "[%s]", deopt_instrs[i]->ToCString());
+    len += OS::SNPrint(NULL, 0, FORMAT, deopt_instrs[i]->ToCString());
   }
 
   // Allocate the buffer.
   char* buffer = Thread::Current()->zone()->Alloc<char>(len);
 
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < deopt_instrs.length(); i++) {
     index += OS::SNPrint((buffer + index),
                          (len - index),
-                         "[%s]",
+                         FORMAT,
                          deopt_instrs[i]->ToCString());
   }
 
   return buffer;
+#undef FORMAT
 }
 
 
 // Returns a bool so it can be asserted.
 bool DeoptInfo::VerifyDecompression(const GrowableArray<DeoptInstr*>& original,
                                     const Array& deopt_table,
                                     const TypedData& packed) {
   GrowableArray<DeoptInstr*> unpacked;
   Unpack(deopt_table, packed, &unpacked);
   ASSERT(unpacked.length() == original.length());
   for (intptr_t i = 0; i < unpacked.length(); ++i) {
     ASSERT(unpacked[i]->Equals(*original[i]));
   }
   return true;
 }
 
 
 const char* ICData::ToCString() const {
-  const char* kFormat = "ICData target:'%s' num-args: %" Pd
-                        " num-checks: %" Pd "";
   const String& name = String::Handle(target_name());
   const intptr_t num_args = NumArgsTested();
   const intptr_t num_checks = NumberOfChecks();
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString(),
-      num_args, num_checks) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, name.ToCString(), num_args, num_checks);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+          "ICData target:'%s' num-args: %" Pd " num-checks: %" Pd "",
+          name.ToCString(), num_args, num_checks);
   return chars;
 }
 
 
 void ICData::set_owner(const Function& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->owner_, value.raw());
 }
 
 
@@ skipping 1813 matching lines @@
 
 
 void ContextScope::SetContextLevelAt(intptr_t scope_index,
                                      intptr_t context_level) const {
   StoreSmi(&(VariableDescAddr(scope_index)->context_level),
            Smi::New(context_level));
 }
 
 
 const char* ContextScope::ToCString() const {
-  const char* format =
-      "%s\nvar %s  token-pos %" Pd "  ctx lvl %" Pd "  index %" Pd "";
   const char* prev_cstr = "ContextScope:";
   String& name = String::Handle();
   for (int i = 0; i < num_variables(); i++) {
     name = NameAt(i);
     const char* cname = name.ToCString();
     intptr_t pos = TokenIndexAt(i);
     intptr_t idx = ContextIndexAt(i);
     intptr_t lvl = ContextLevelAt(i);
-    intptr_t len =
-        OS::SNPrint(NULL, 0, format, prev_cstr, cname, pos, lvl, idx) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, prev_cstr, cname, pos, lvl, idx);
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+            "%s\nvar %s  token-pos %" Pd "  ctx lvl %" Pd "  index %" Pd "",
+            prev_cstr, cname, pos, lvl, idx);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 void ContextScope::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
@@ skipping 461 matching lines @@
       exc_str = "<Received error while converting exception to string>";
     }
   }
   const Instance& stack = Instance::Handle(stacktrace());
   strtmp = DartLibraryCalls::ToString(stack);
   const char* stack_str =
       "<Received error while converting stack trace to string>";
   if (!strtmp.IsError()) {
     stack_str = strtmp.ToCString();
   }
-  const char* format = "Unhandled exception:\n%s\n%s";
-  intptr_t len = OS::SNPrint(NULL, 0, format, exc_str, stack_str);
-  char* chars = thread->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, exc_str, stack_str);
+  char* chars = NULL;
+  SNPRINT(chars, thread->zone()->Alloc<char>, "Unhandled exception:\n%s\n%s",
+          exc_str, stack_str);
   return chars;
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
 
@@ skipping 141 matching lines @@
          field_offset <= end_field_offset;
          field_offset += kWordSize) {
       obj = *this->FieldAddrAtOffset(field_offset);
       if (obj.IsInstance() && !obj.IsSmi() && !obj.IsCanonical()) {
         if (obj.IsNumber() || obj.IsString()) {
           obj = Instance::Cast(obj).CheckAndCanonicalize(NULL);
           ASSERT(!obj.IsNull());
           this->SetFieldAtOffset(field_offset, obj);
         } else {
           ASSERT(error_str != NULL);
-          const char* kFormat = "field: %s\n";
-          const intptr_t len =
-              OS::SNPrint(NULL, 0, kFormat, obj.ToCString()) + 1;
-          char* chars = Thread::Current()->zone()->Alloc<char>(len);
-          OS::SNPrint(chars, len, kFormat, obj.ToCString());
+          char* chars = NULL;
+          SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "field: %s\n",
+                  obj.ToCString());
           *error_str = chars;
           return false;
         }
       }
     }
   } else {
 #if defined(DEBUG)
     // Make sure that we are not missing any fields.
     CheckForPointers has_pointers(Isolate::Current());
     this->raw()->VisitPointers(&has_pointers);
@@ skipping 303 matching lines @@
     return "unknown_constant";
   } else if (raw() == Object::non_constant().raw()) {
     return "non_constant";
   } else if (Thread::Current()->no_safepoint_scope_depth() > 0) {
     // Can occur when running disassembler.
     return "Instance";
   } else {
     if (IsClosure()) {
       return Closure::ToCString(*this);
     }
-    const char* kFormat = "Instance of '%s'";
     const Class& cls = Class::Handle(clazz());
     TypeArguments& type_arguments = TypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type =
         Type::Handle(Type::New(cls, type_arguments, Scanner::kNoSourcePos));
     const String& type_name = String::Handle(type.UserVisibleName());
-    // Calculate the size of the string.
-    intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, kFormat, type_name.ToCString());
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "Instance of '%s'",
+            type_name.ToCString());
     return chars;
   }
 }
 
 
 void Instance::PrintSharedInstanceJSON(JSONObject* jsobj,
                                        bool ref) const {
   AddCommonObjectProperties(jsobj, "Instance", ref);
   if (ref) {
     return;
@@ skipping 1152 matching lines @@
   const char* unresolved = IsResolved() ? "" : "Unresolved ";
   const TypeArguments& type_arguments = TypeArguments::Handle(arguments());
   const char* class_name;
   if (HasResolvedTypeClass()) {
     class_name = String::Handle(
         Class::Handle(type_class()).Name()).ToCString();
   } else {
     class_name = UnresolvedClass::Handle(unresolved_class()).ToCString();
   }
   if (type_arguments.IsNull()) {
-    const char* format = "%sType: class '%s'";
-    const intptr_t len =
-        OS::SNPrint(NULL, 0, format, unresolved, class_name) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, unresolved, class_name);
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+            "%sType: class '%s'", unresolved, class_name);
     return chars;
   } else if (IsResolved() && IsFinalized() && IsRecursive()) {
-    const char* format = "Type: (@%" Px " H%" Px ") class '%s', args:[%s]";
     const intptr_t hash = Hash();
     const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
-    const intptr_t len =
-        OS::SNPrint(NULL, 0, format, raw(), hash, class_name, args_cstr) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, raw(), hash, class_name, args_cstr);
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+            "Type: (@%p H%" Px ") class '%s', args:[%s]",
+            raw(), hash, class_name, args_cstr);
     return chars;
   } else {
-    const char* format = "%sType: class '%s', args:[%s]";
     const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
-    const intptr_t len =
-        OS::SNPrint(NULL, 0, format, unresolved, class_name, args_cstr) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, unresolved, class_name, args_cstr);
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+            "%sType: class '%s', args:[%s]", unresolved, class_name, args_cstr);
     return chars;
   }
 }
 
 
 void Type::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Type");
   if (IsCanonical()) {
@@ skipping 162 matching lines @@
   result.set_type(type);
   return result.raw();
 }
 
 
 const char* TypeRef::ToCString() const {
   const char* type_cstr = String::Handle(Class::Handle(
       type_class()).Name()).ToCString();
   AbstractType& ref_type = AbstractType::Handle(type());
   if (ref_type.IsFinalized()) {
-    const char* format = "TypeRef: %s<...> (@%" Px " H%" Px ")";
     const intptr_t hash = ref_type.Hash();
-    const intptr_t len =
-        OS::SNPrint(NULL, 0, format, type_cstr, ref_type.raw(), hash) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, type_cstr, ref_type.raw(), hash);
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+            "TypeRef: %s<...> (@%p H%" Px ")",
+            type_cstr, ref_type.raw(), hash);
     return chars;
   } else {
-    const char* format = "TypeRef: %s<...>";
-    const intptr_t len = OS::SNPrint(NULL, 0, format, type_cstr) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
-    OS::SNPrint(chars, len, format, type_cstr);
+    char* chars = NULL;
+    SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "TypeRef: %s<...>",
+            type_cstr);
     return chars;
   }
 }
 
 
 void TypeRef::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "TypeRef");
   jsobj.AddServiceId(*this);
@@ skipping 970 matching lines @@
       return this->IsNegative() ? 1 : -1;
     }
     return this->IsNegative() ? -1 : 1;
   }
   UNREACHABLE();
   return 0;
 }
 
 
 const char* Smi::ToCString() const {
-  const char* kFormat = "%ld";
-  // Calculate the size of the string.
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, Value()) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, Value());
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "%" Pd "", Value());
   return chars;
 }
 
 
 void Smi::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Int");
   jsobj.AddFixedServiceId("objects/int-%" Pd "", Value());
   jsobj.AddPropertyF("valueAsString", "%" Pd "", Value());
@@ skipping 106 matching lines @@
   ASSERT(other.IsBigint());
   ASSERT(!Bigint::Cast(other).FitsIntoInt64());
   if (this->IsNegative() == other.IsNegative()) {
     return this->IsNegative() ? 1 : -1;
   }
   return this->IsNegative() ? -1 : 1;
 }
 
 
 const char* Mint::ToCString() const {
-  const char* kFormat = "%lld";
-  // Calculate the size of the string.
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, value()) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, value());
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "%lld", value());
   return chars;
 }
 
 
 void Mint::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Integer::PrintJSONImpl(stream, ref);
 }
 
 
 void Double::set_value(double value) const {
@@ skipping 2828 matching lines @@
   // other instances to be canonical otherwise report error (return false).
   for (intptr_t i = 0; i < Length(); i++) {
     obj = At(i);
     if (obj.IsInstance() && !obj.IsSmi() && !obj.IsCanonical()) {
       if (obj.IsNumber() || obj.IsString()) {
         obj = Instance::Cast(obj).CheckAndCanonicalize(NULL);
         ASSERT(!obj.IsNull());
         this->SetAt(i, obj);
       } else {
         ASSERT(error_str != NULL);
-        const char* kFormat = "element at index %" Pd ": %s\n";
-        const intptr_t len =
-            OS::SNPrint(NULL, 0, kFormat, i, obj.ToCString()) + 1;
-        char* chars = Thread::Current()->zone()->Alloc<char>(len);
-        OS::SNPrint(chars, len, kFormat, i, obj.ToCString());
+        char* chars = NULL;
+        SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+                "element at index %" Pd ": %s\n", i, obj.ToCString());
         *error_str = chars;
         return false;
       }
     }
   }
   return true;
 }
 
 
 RawImmutableArray* ImmutableArray::New(intptr_t len,
@@ skipping 103 matching lines @@
     result.SetData(array);
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   if (IsNull()) {
     return "_GrowableList NULL";
   }
-  const char* format = "Instance(length:%" Pd ") of '_GrowableList'";
-  intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, Length());
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+          "Instance(length:%" Pd ") of '_GrowableList'", Length());
   return chars;
 }
 
 
 void GrowableObjectArray::PrintJSONImpl(JSONStream* stream,
                                         bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "List");
   jsobj.AddServiceId(*this);
@@ skipping 202 matching lines @@
   return raw_ptr()->value_[2];
 }
 
 
 float Float32x4::w() const {
   return raw_ptr()->value_[3];
 }
 
 
 const char* Float32x4::ToCString() const {
-  const char* kFormat = "[%f, %f, %f, %f]";
   float _x = x();
   float _y = y();
   float _z = z();
   float _w = w();
-  // Calculate the size of the string.
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "[%f, %f, %f, %f]",
+          _x, _y, _z, _w);
   return chars;
 }
 
 
 void Float32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Float32x4");
   jsobj.AddServiceId(*this);
   jsobj.AddProperty("valueAsString", ToCString());
@@ skipping 80 matching lines @@
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
 void Int32x4::set_value(simd128_value_t value) const {
   StoreSimd128(&raw_ptr()->value_[0], value);
 }
 
 
 const char* Int32x4::ToCString() const {
-  const char* kFormat = "[%08x, %08x, %08x, %08x]";
   int32_t _x = x();
   int32_t _y = y();
   int32_t _z = z();
   int32_t _w = w();
-  // Calculate the size of the string.
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+          "[%08x, %08x, %08x, %08x]", _x, _y, _z, _w);
   return chars;
 }
 
 
 void Int32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Int32x4");
   jsobj.AddServiceId(*this);
   jsobj.AddProperty("valueAsString", ToCString());
@@ skipping 57 matching lines @@
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
 void Float64x2::set_value(simd128_value_t value) const {
   StoreSimd128(&raw_ptr()->value_[0], value);
 }
 
 
 const char* Float64x2::ToCString() const {
-  const char* kFormat = "[%f, %f]";
   double _x = x();
   double _y = y();
-  // Calculate the size of the string.
-  intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, kFormat, _x, _y);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "[%f, %f]", _x, _y);
   return chars;
 }
 
 
 void Float64x2::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Float64x2");
   jsobj.AddServiceId(*this);
   jsobj.AddProperty("valueAsString", ToCString());
@@ skipping 250 matching lines @@
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 const char* Closure::ToCString(const Instance& closure) {
   const Function& fun = Function::Handle(Closure::function(closure));
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.UserVisibleSignature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
-  const char* format = "Closure: %s%s%s";
-  intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
-  char* chars = Thread::Current()->zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, fun_sig, from, fun_desc);
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>, "Closure: %s%s%s",
+          fun_sig, from, fun_desc);
   return chars;
 }
 
 
 RawInstance* Closure::New(const Function& function,
                           const Context& context,
                           Heap::Space space) {
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(cls.instance_size() == Closure::InstanceSize());
   Instance& result = Instance::Handle();
@@ skipping 99 matching lines @@
   jsobj.AddProperty("valueAsString", ToCStringInternal(&idx));
 }
 
 
 static intptr_t PrintOneStacktrace(Zone* zone,
                                    GrowableArray<char*>* frame_strings,
                                    uword pc,
                                    const Function& function,
                                    const Code& code,
                                    intptr_t frame_index) {
-  const char* kFormatWithCol = "#%-6d %s (%s:%d:%d)\n";
-  const char* kFormatNoCol = "#%-6d %s (%s:%d)\n";
-  const char* kFormatNoLine = "#%-6d %s (%s)\n";
   const intptr_t token_pos = code.GetTokenIndexOfPC(pc);
   const Script& script = Script::Handle(zone, function.script());
   const String& function_name =
       String::Handle(zone, function.QualifiedUserVisibleName());
   const String& url = String::Handle(zone, script.url());
   intptr_t line = -1;
   intptr_t column = -1;
   if (token_pos > 0) {
     if (script.HasSource()) {
       script.GetTokenLocation(token_pos, &line, &column);
     } else {
       script.GetTokenLocation(token_pos, &line, NULL);
     }
   }
-  intptr_t len = 0;
   char* chars = NULL;
   if (column >= 0) {
-    len = OS::SNPrint(NULL, 0, kFormatWithCol,
-                      frame_index, function_name.ToCString(),
-                      url.ToCString(), line, column);
-    chars = zone->Alloc<char>(len + 1);
-    OS::SNPrint(chars, (len + 1), kFormatWithCol,
-                frame_index,
-                function_name.ToCString(),
-                url.ToCString(), line, column);
+    SNPRINT(chars, zone->Alloc<char>, "#%-6d %s (%s:%d:%d)\n",
+            frame_index, function_name.ToCString(), url.ToCString(), line,
+            column);
   } else if (line >= 0) {
-    len = OS::SNPrint(NULL, 0, kFormatNoCol,
-                      frame_index, function_name.ToCString(),
-                      url.ToCString(), line);
-    chars = zone->Alloc<char>(len + 1);
-    OS::SNPrint(chars, (len + 1), kFormatNoCol,
-                frame_index, function_name.ToCString(),
-                url.ToCString(), line);
+    SNPRINT(chars, zone->Alloc<char>, "#%-6d %s (%s:%d)\n",
+            frame_index, function_name.ToCString(), url.ToCString(), line);
   } else {
-    len = OS::SNPrint(NULL, 0, kFormatNoLine,
-                      frame_index, function_name.ToCString(),
-                      url.ToCString());
-    chars = zone->Alloc<char>(len + 1);
-    OS::SNPrint(chars, (len + 1), kFormatNoLine,
-                frame_index, function_name.ToCString(),
-                url.ToCString());
+    SNPRINT(chars, zone->Alloc<char>, "#%-6d %s (%s)\n",
+            frame_index, function_name.ToCString(), url.ToCString());
   }
   frame_strings->Add(chars);
-  return len;
+  return strlen(chars);
 }
 
 
 const char* Stacktrace::ToCStringInternal(intptr_t* frame_index,
                                           intptr_t max_frames) const {
   Zone* zone = Thread::Current()->zone();
   Function& function = Function::Handle();
   Code& code = Code::Handle();
   // Iterate through the stack frames and create C string description
   // for each frame.
@@ skipping 146 matching lines @@
       (is_ignore_case() != other_js.is_ignore_case()) ||
       (is_multi_line() != other_js.is_multi_line())) {
     return false;
   }
   return true;
 }
 
 
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
-  const char* format = "JSRegExp: pattern=%s flags=%s";
-  intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
-  char* chars = Thread::Current()->zone()->Alloc<char>(len + 1);
-  OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
+  char* chars = NULL;
+  SNPRINT(chars, Thread::Current()->zone()->Alloc<char>,
+          "JSRegExp: pattern=%s flags=%s", str.ToCString(), Flags());
   return chars;
 }
 
 
 void JSRegExp::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "RegExp");
   jsobj.AddServiceId(*this);
 
@@ skipping 246 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart