fix cpp11 compile errors

runtime/vm/isolate.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 "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "lib/mirrors.h"
@@ skipping 255 matching lines @@
   ASSERT(isolate == Isolate::Current());
 }
 #endif
 
 
 void DeferredDouble::Materialize() {
   RawDouble** double_slot = reinterpret_cast<RawDouble**>(slot());
   *double_slot = Double::New(value());
 
   if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("materializing double at %"Px": %g\n",
+    OS::PrintErr("materializing double at %" Px ": %g\n",
                  reinterpret_cast<uword>(slot()), value());
   }
 }
 
 
 void DeferredMint::Materialize() {
   RawMint** mint_slot = reinterpret_cast<RawMint**>(slot());
   ASSERT(!Smi::IsValid64(value()));
   Mint& mint = Mint::Handle();
   mint ^= Integer::New(value());
   *mint_slot = mint.raw();
 
   if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("materializing mint at %"Px": %"Pd64"\n",
+    OS::PrintErr("materializing mint at %" Px ": %" Pd64 "\n",
                  reinterpret_cast<uword>(slot()), value());
   }
 }
 
 
 void DeferredFloat32x4::Materialize() {
   RawFloat32x4** float32x4_slot = reinterpret_cast<RawFloat32x4**>(slot());
   RawFloat32x4* raw_float32x4 = Float32x4::New(value());
   *float32x4_slot = raw_float32x4;
 
   if (FLAG_trace_deoptimization_verbose) {
     float x = raw_float32x4->x();
     float y = raw_float32x4->y();
     float z = raw_float32x4->z();
     float w = raw_float32x4->w();
-    OS::PrintErr("materializing Float32x4 at %"Px": %g,%g,%g,%g\n",
+    OS::PrintErr("materializing Float32x4 at %" Px ": %g,%g,%g,%g\n",
                  reinterpret_cast<uword>(slot()), x, y, z, w);
   }
 }
 
 
 void DeferredUint32x4::Materialize() {
   RawUint32x4** uint32x4_slot = reinterpret_cast<RawUint32x4**>(slot());
   RawUint32x4* raw_uint32x4 = Uint32x4::New(value());
   *uint32x4_slot = raw_uint32x4;
 
   if (FLAG_trace_deoptimization_verbose) {
     uint32_t x = raw_uint32x4->x();
     uint32_t y = raw_uint32x4->y();
     uint32_t z = raw_uint32x4->z();
     uint32_t w = raw_uint32x4->w();
-    OS::PrintErr("materializing Uint32x4 at %"Px": %x,%x,%x,%x\n",
+    OS::PrintErr("materializing Uint32x4 at %" Px ": %x,%x,%x,%x\n",
                  reinterpret_cast<uword>(slot()), x, y, z, w);
   }
 }
 
 
 void DeferredObjectRef::Materialize() {
   DeferredObject* obj = Isolate::Current()->GetDeferredObject(index());
   *slot() = obj->object();
   if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("writing instance ref at %"Px": %s\n",
+    OS::PrintErr("writing instance ref at %" Px ": %s\n",
                  reinterpret_cast<uword>(slot()),
                  Instance::Handle(obj->object()).ToCString());
   }
 }
 
 
 RawInstance* DeferredObject::object() {
   if (object_ == NULL) {
     Materialize();
   }
   return object_->raw();
 }
 
 
 void DeferredObject::Materialize() {
   Class& cls = Class::Handle();
   cls ^= GetClass();
 
   if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("materializing instance of %s (%"Px", %"Pd" fields)\n",
+    OS::PrintErr("materializing instance of %s (%" Px ", %" Pd " fields)\n",
                  cls.ToCString(),
                  reinterpret_cast<uword>(args_),
                  field_count_);
   }
 
   const Instance& obj = Instance::ZoneHandle(Instance::New(cls));
 
   Field& field = Field::Handle();
   Object& value = Object::Handle();
   for (intptr_t i = 0; i < field_count_; i++) {
@@ skipping 360 matching lines @@
     Class& cls = Class::Handle();
     ClassDictionaryIterator iter(library,
                                  ClassDictionaryIterator::kIteratePrivate);
     while (iter.HasNext()) {
       cls = iter.GetNextClass();
       AddFunctionsFromClass(cls, &invoked_functions);
     }
   }
   invoked_functions.Sort(MostUsedFunctionFirst);
   for (int i = 0; i < invoked_functions.length(); i++) {
-    OS::Print("%10"Pd" x %s\n",
+    OS::Print("%10" Pd " x %s\n",
         invoked_functions[i]->usage_counter(),
         invoked_functions[i]->ToFullyQualifiedCString());
   }
 }
 
 
 class FinalizeWeakPersistentHandlesVisitor : public HandleVisitor {
  public:
   FinalizeWeakPersistentHandlesVisitor() {
   }
@@ skipping 130 matching lines @@
 
 
 static Monitor* status_sync = NULL;
 
 
 bool Isolate::FetchStacktrace() {
   Isolate* isolate = Isolate::Current();
   MonitorLocker ml(status_sync);
   DebuggerStackTrace* stack = Debugger::CollectStackTrace();
   TextBuffer buffer(256);
-  buffer.Printf("{ \"handle\": \"0x%"Px64"\", \"stacktrace\": [ ",
+  buffer.Printf("{ \"handle\": \"0x%" Px64 "\", \"stacktrace\": [ ",
                 reinterpret_cast<int64_t>(isolate));
   intptr_t n_frames = stack->Length();
   String& url = String::Handle();
   String& function = String::Handle();
   for (int i = 0; i < n_frames; i++) {
     if (i > 0) {
       buffer.Printf(", ");
     }
     ActivationFrame* frame = stack->ActivationFrameAt(i);
     url ^= frame->SourceUrl();
     function ^= frame->function().UserVisibleName();
     buffer.Printf("{ \"url\": \"%s\", ", url.ToCString());
-    buffer.Printf("\"line\": %"Pd", ", frame->LineNumber());
+    buffer.Printf("\"line\": %" Pd ", ", frame->LineNumber());
     buffer.Printf("\"function\": \"%s\", ", function.ToCString());
 
     const Code& code = frame->code();
     buffer.Printf("\"code\": { ");
     buffer.Printf("\"alive\": %s, ", code.is_alive() ? "false" : "true");
     buffer.Printf("\"optimized\": %s }}",
         code.is_optimized() ? "false" : "true");
   }
   buffer.Printf("]}");
   isolate->stacktrace_ = OS::StrNDup(buffer.buf(), buffer.length());
   ml.Notify();
   return true;
 }
 
 
 bool Isolate::FetchStackFrameDetails() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->stack_frame_index_ >= 0);
   MonitorLocker ml(status_sync);
   DebuggerStackTrace* stack = Debugger::CollectStackTrace();
   intptr_t frame_index = isolate->stack_frame_index_;
   if (frame_index >= stack->Length()) {
     // Frame no longer available.
     return NULL;
   }
   ActivationFrame* frame = stack->ActivationFrameAt(frame_index);
   TextBuffer buffer(256);
-  buffer.Printf("{ \"handle\": \"0x%"Px64"\", \"frame_index\": %"Pd", ",
+  buffer.Printf("{ \"handle\": \"0x%" Px64 "\", \"frame_index\": %" Pd ", ",
        reinterpret_cast<int64_t>(isolate), frame_index);
 
   const Code& code = frame->code();
-  buffer.Printf("\"code\": { \"size\": %"Pd", ", code.Size());
+  buffer.Printf("\"code\": { \"size\": %" Pd ", ", code.Size());
   buffer.Printf("\"alive\": %s, ", code.is_alive() ? "false" : "true");
   buffer.Printf("\"optimized\": %s }, ",
       code.is_optimized() ? "false" : "true");
   // TODO(tball): add compilation stats (time, etc.), when available.
 
   buffer.Printf("\"local_vars\": [ ");
   intptr_t n_local_vars = frame->NumLocalVariables();
   String& var_name = String::Handle();
   Instance& value = Instance::Handle();
   for (int i = 0; i < n_local_vars; i++) {
     if (i > 0) {
       buffer.Printf(", ");
     }
     intptr_t token_pos, end_pos;
     frame->VariableAt(i, &var_name, &token_pos, &end_pos, &value);
     buffer.Printf(
-        "{ \"name\": \"%s\", \"pos\": %"Pd", \"end_pos\": %"Pd", "
+        "{ \"name\": \"%s\", \"pos\": %" Pd ", \"end_pos\": %" Pd ", "
         "\"value\": \"%s\" }",
         var_name.ToCString(), token_pos, end_pos, value.ToCString());
   }
   buffer.Printf("]}");
   isolate->stacktrace_ = OS::StrNDup(buffer.buf(), buffer.length());
   ml.Notify();
   return true;
 }
 
 
@@ skipping 11 matching lines @@
         ml.Wait(1000);
       }
     }
     SetVmStatsCallback(NULL);
   }
   char* result = stacktrace_;
   stacktrace_ = NULL;
   if (result == NULL) {
     // Return empty stack.
     TextBuffer buffer(256);
-    buffer.Printf("{ \"handle\": \"0x%"Px64"\", \"stacktrace\": []}",
+    buffer.Printf("{ \"handle\": \"0x%" Px64 "\", \"stacktrace\": []}",
                   reinterpret_cast<int64_t>(this));
 
     result = OS::StrNDup(buffer.buf(), buffer.length());
   }
   ASSERT(result != NULL);
   // result is freed by VmStats::WebServer().
   return result;
 }
 
 
 char* Isolate::GetStatusStacktrace() {
   return DoStacktraceInterrupt(&FetchStacktrace);
 }
 
 char* Isolate::GetStatusStackFrame(intptr_t index) {
   ASSERT(index >= 0);
   stack_frame_index_ = index;
   char* result = DoStacktraceInterrupt(&FetchStackFrameDetails);
   stack_frame_index_ = -1;
   return result;
 }
 
 
 // Returns the isolate's general detail information.
 char* Isolate::GetStatusDetails() {
   const char* format = "{\n"
-      "  \"handle\": \"0x%"Px64"\",\n"
+      "  \"handle\": \"0x%" Px64 "\",\n"
       "  \"name\": \"%s\",\n"
-      "  \"port\": %"Pd",\n"
-      "  \"starttime\": %"Pd",\n"
-      "  \"stacklimit\": %"Pd",\n"
+      "  \"port\": %" Pd ",\n"
+      "  \"starttime\": %" Pd ",\n"
+      "  \"stacklimit\": %" Pd ",\n"
       "  \"newspace\": {\n"
-      "    \"used\": %"Pd",\n"
-      "    \"capacity\": %"Pd"\n"
+      "    \"used\": %" Pd ",\n"
+      "    \"capacity\": %" Pd "\n"
       "  },\n"
       "  \"oldspace\": {\n"
-      "    \"used\": %"Pd",\n"
-      "    \"capacity\": %"Pd"\n"
+      "    \"used\": %" Pd ",\n"
+      "    \"capacity\": %" Pd "\n"
       "  }\n"
       "}";
   char buffer[300];
   int64_t address = reinterpret_cast<int64_t>(this);
   int n = OS::SNPrint(buffer, 300, format, address, name(), main_port(),
                       (start_time() / 1000L), saved_stack_limit(),
                       heap()->Used(Heap::kNew) / KB,
                       heap()->Capacity(Heap::kNew) / KB,
                       heap()->Used(Heap::kOld) / KB,
                       heap()->Capacity(Heap::kOld) / KB);
@@ skipping 158 matching lines @@
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(isolate());
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart