fix cpp11 compile errors

runtime/vm/il_printer.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/il_printer.h"
 
 #include "vm/intermediate_language.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
@@ skipping 65 matching lines @@
   char str[1000];
   BufferFormatter f(str, sizeof(str));
   instr->PrintTo(&f);
   if (FLAG_print_environments && (instr->env() != NULL)) {
     instr->env()->PrintTo(&f);
   }
   if (print_locations && (instr->locs() != NULL)) {
     instr->locs()->PrintTo(&f);
   }
   if (instr->lifetime_position() != -1) {
-    OS::Print("%3"Pd": ", instr->lifetime_position());
+    OS::Print("%3" Pd ": ", instr->lifetime_position());
   }
   if (!instr->IsBlockEntry()) OS::Print("    ");
   OS::Print("%s", str);
 }
 
 
 void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
                                       intptr_t token_pos,
                                       Value* value,
                                       const AbstractType& dst_type,
@@ skipping 29 matching lines @@
 
 const char* CompileType::ToCString() const {
   char buffer[1024];
   BufferFormatter f(buffer, sizeof(buffer));
   PrintTo(&f);
   return Isolate::Current()->current_zone()->MakeCopyOfString(buffer);
 }
 
 
 static void PrintICData(BufferFormatter* f, const ICData& ic_data) {
-  f->Print(" IC[%"Pd": ", ic_data.NumberOfChecks());
+  f->Print(" IC[%" Pd ": ", ic_data.NumberOfChecks());
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     const intptr_t count = ic_data.GetCountAt(i);
     if (i > 0) {
       f->Print(" | ");
     }
     for (intptr_t k = 0; k < class_ids.length(); k++) {
       if (k > 0) {
         f->Print(", ");
       }
       const Class& cls =
           Class::Handle(Isolate::Current()->class_table()->At(class_ids[k]));
       f->Print("%s", String::Handle(cls.Name()).ToCString());
     }
     if (count > 0) {
-      f->Print(" #%"Pd, count);
+      f->Print(" #%" Pd, count);
     }
     f->Print(" <%p>", static_cast<void*>(target.raw()));
   }
   f->Print("]");
 }
 
 
 static void PrintUse(BufferFormatter* f, const Definition& definition) {
   if (definition.is_used()) {
     if (definition.HasSSATemp()) {
-      f->Print("v%"Pd, definition.ssa_temp_index());
+      f->Print("v%" Pd, definition.ssa_temp_index());
     } else if (definition.temp_index() != -1) {
-      f->Print("t%"Pd, definition.temp_index());
+      f->Print("t%" Pd, definition.temp_index());
     }
   }
 }
 
 
 const char* Instruction::ToCString() const {
   char buffer[1024];
   BufferFormatter f(buffer, sizeof(buffer));
   PrintTo(&f);
   return Isolate::Current()->current_zone()->MakeCopyOfString(buffer);
 }
 
 
 void Instruction::PrintTo(BufferFormatter* f) const {
   if (GetDeoptId() != Isolate::kNoDeoptId) {
-    f->Print("%s:%"Pd"(", DebugName(), GetDeoptId());
+    f->Print("%s:%" Pd "(", DebugName(), GetDeoptId());
   } else {
     f->Print("%s(", DebugName());
   }
   PrintOperandsTo(f);
   f->Print(")");
 }
 
 
 void Instruction::PrintOperandsTo(BufferFormatter* f) const {
   for (int i = 0; i < InputCount(); ++i) {
     if (i > 0) f->Print(", ");
     if (InputAt(i) != NULL) InputAt(i)->PrintTo(f);
   }
 }
 
 
 void Definition::PrintTo(BufferFormatter* f) const {
   PrintUse(f, *this);
   if (is_used()) {
     if (HasSSATemp() || (temp_index() != -1)) f->Print(" <- ");
   }
   if (GetDeoptId() != Isolate::kNoDeoptId) {
-    f->Print("%s:%"Pd"(", DebugName(), GetDeoptId());
+    f->Print("%s:%" Pd "(", DebugName(), GetDeoptId());
   } else {
     f->Print("%s(", DebugName());
   }
   PrintOperandsTo(f);
   f->Print(")");
   if (range_ != NULL) {
     f->Print(" ");
     range_->PrintTo(f);
   }
 
@@ skipping 59 matching lines @@
   char buffer[256];
   BufferFormatter f(buffer, sizeof(buffer));
   range->PrintTo(&f);
   return Isolate::Current()->current_zone()->MakeCopyOfString(buffer);
 }
 
 
 void RangeBoundary::PrintTo(BufferFormatter* f) const {
   switch (kind_) {
     case kSymbol:
-      f->Print("v%"Pd, reinterpret_cast<Definition*>(value_)->ssa_temp_index());
-      if (offset_ != 0) f->Print("%+"Pd, offset_);
+      f->Print("v%" Pd,
+               reinterpret_cast<Definition*>(value_)->ssa_temp_index());
+      if (offset_ != 0) f->Print("%+" Pd, offset_);
       break;
     case kConstant:
       if (value_ == kMinusInfinity) {
         f->Print("-inf");
       } else if (value_ == kPlusInfinity) {
         f->Print("+inf");
       } else {
-        f->Print("%"Pd, value_);
+        f->Print("%" Pd, value_);
       }
       break;
     case kUnknown:
       f->Print("_|_");
       break;
   }
 }
 
 
 const char* RangeBoundary::ToCString() const {
@@ skipping 106 matching lines @@
 
   f->Print("%s [%s %s], ",
            String::Handle(field().name()).ToCString(),
            field().is_nullable() ? "nullable" : "non-nullable",
            expected);
   value()->PrintTo(f);
 }
 
 
 void StoreInstanceFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%s {%"Pd"}, ",
+  f->Print("%s {%" Pd "}, ",
            String::Handle(field().name()).ToCString(),
            field().Offset());
   instance()->PrintTo(f);
   f->Print(", ");
   value()->PrintTo(f);
 }
 
 
 void IfThenElseInstr::PrintOperandsTo(BufferFormatter* f) const {
   left()->PrintTo(f);
   f->Print(" %s ", Token::Str(kind_));
   right()->PrintTo(f);
-  f->Print(" ? %"Pd" : %"Pd,
+  f->Print(" ? %" Pd " : %" Pd,
            if_true_,
            if_false_);
 }
 
 
 void LoadStaticFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   field_value()->PrintTo(f);
 }
 
 
@@ skipping 71 matching lines @@
   f->Print("%s", function().ToCString());
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     if (i > 0) f->Print(", ");
     PushArgumentAt(i)->value()->PrintTo(f);
   }
 }
 
 
 void LoadFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   instance()->PrintTo(f);
-  f->Print(", %"Pd, offset_in_bytes());
+  f->Print(", %" Pd, offset_in_bytes());
 
   if (field() != NULL) {
     f->Print(" {%s}", String::Handle(field()->name()).ToCString());
     const char* expected = "?";
     if (field()->guarded_cid() != kIllegalCid) {
       const Class& cls = Class::Handle(
             Isolate::Current()->class_table()->At(field()->guarded_cid()));
       expected = String::Handle(cls.Name()).ToCString();
     }
 
     f->Print(" [%s %s]",
              field()->is_nullable() ? "nullable" : "non-nullable",
              expected);
   }
 
   f->Print(", immutable=%d", immutable_);
 }
 
 
 void StoreVMFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   dest()->PrintTo(f);
-  f->Print(", %"Pd", ", offset_in_bytes());
+  f->Print(", %" Pd ", ", offset_in_bytes());
   value()->PrintTo(f);
 }
 
 
 void InstantiateTypeInstr::PrintOperandsTo(BufferFormatter* f) const {
   const String& type_name = String::Handle(type().Name());
   f->Print("%s, ", type_name.ToCString());
   instantiator()->PrintTo(f);
 }
 
 
 void InstantiateTypeArgumentsInstr::PrintOperandsTo(BufferFormatter* f) const {
   const String& type_args = String::Handle(type_arguments().Name());
   f->Print("%s, ", type_args.ToCString());
   instantiator()->PrintTo(f);
 }
 
 
 void ExtractConstructorTypeArgumentsInstr::PrintOperandsTo(
     BufferFormatter* f) const {
   const String& type_args = String::Handle(type_arguments().Name());
   f->Print("%s, ", type_args.ToCString());
   instantiator()->PrintTo(f);
 }
 
 
 void AllocateContextInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%"Pd"", num_context_variables());
+  f->Print("%" Pd "", num_context_variables());
 }
 
 
 void BinarySmiOpInstr::PrintTo(BufferFormatter* f) const {
   Definition::PrintTo(f);
   f->Print(" %co", overflow_ ? '+' : '-');
   f->Print(" %ct", is_truncating() ? '+' : '-');
 }
 
 
@@ skipping 211 matching lines @@
 
 
 void InvokeMathCFunctionInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", MethodRecognizer::KindToCString(recognized_kind_));
   Definition::PrintOperandsTo(f);
 }
 
 
 void GraphEntryInstr::PrintTo(BufferFormatter* f) const {
   const GrowableArray<Definition*>& defns = initial_definitions_;
-  f->Print("B%"Pd"[graph]:%"Pd, block_id(), GetDeoptId());
+  f->Print("B%" Pd "[graph]:%" Pd, block_id(), GetDeoptId());
   if (defns.length() > 0) {
     f->Print(" {");
     for (intptr_t i = 0; i < defns.length(); ++i) {
       Definition* def = defns[i];
       f->Print("\n      ");
       def->PrintTo(f);
     }
     f->Print("\n}");
   }
 }
 
 
 void JoinEntryInstr::PrintTo(BufferFormatter* f) const {
   if (try_index() != CatchClauseNode::kInvalidTryIndex) {
-    f->Print("B%"Pd"[join try_idx %"Pd"]:%"Pd" pred(",
+    f->Print("B%" Pd "[join try_idx %" Pd "]:%" Pd " pred(",
              block_id(), try_index(), GetDeoptId());
   } else {
-    f->Print("B%"Pd"[join]:%"Pd" pred(", block_id(), GetDeoptId());
+    f->Print("B%" Pd "[join]:%" Pd " pred(", block_id(), GetDeoptId());
   }
   for (intptr_t i = 0; i < predecessors_.length(); ++i) {
     if (i > 0) f->Print(", ");
-    f->Print("B%"Pd, predecessors_[i]->block_id());
+    f->Print("B%" Pd, predecessors_[i]->block_id());
   }
   f->Print(")");
   if (phis_ != NULL) {
     f->Print(" {");
     for (intptr_t i = 0; i < phis_->length(); ++i) {
       if ((*phis_)[i] == NULL) continue;
       f->Print("\n      ");
       (*phis_)[i]->PrintTo(f);
     }
     f->Print("\n}");
   }
   if (HasParallelMove()) {
     f->Print(" ");
     parallel_move()->PrintTo(f);
   }
 }
 
 
 void PhiInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("v%"Pd" <- phi(", ssa_temp_index());
+  f->Print("v%" Pd " <- phi(", ssa_temp_index());
   for (intptr_t i = 0; i < inputs_.length(); ++i) {
     if (inputs_[i] != NULL) inputs_[i]->PrintTo(f);
     if (i < inputs_.length() - 1) f->Print(", ");
   }
   f->Print(")");
   if (is_alive()) {
     f->Print(" alive");
   } else {
     f->Print(" dead");
   }
   if (range_ != NULL) {
     f->Print(" ");
     range_->PrintTo(f);
   }
   if (type_ != NULL) {
     f->Print(" ");
     type_->PrintTo(f);
   }
 }
 
 
 void ParameterInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%"Pd, index());
+  f->Print("%" Pd, index());
 }
 
 
 void CheckStackOverflowInstr::PrintOperandsTo(BufferFormatter* f) const {
-  if (in_loop()) f->Print("depth %"Pd, loop_depth());
+  if (in_loop()) f->Print("depth %" Pd, loop_depth());
 }
 
 
 void TargetEntryInstr::PrintTo(BufferFormatter* f) const {
   if (try_index() != CatchClauseNode::kInvalidTryIndex) {
-    f->Print("B%"Pd"[target try_idx %"Pd"]:%"Pd,
+    f->Print("B%" Pd "[target try_idx %" Pd "]:%" Pd,
              block_id(), try_index(), GetDeoptId());
   } else {
-    f->Print("B%"Pd"[target]:%"Pd, block_id(), GetDeoptId());
+    f->Print("B%" Pd "[target]:%" Pd, block_id(), GetDeoptId());
   }
   if (HasParallelMove()) {
     f->Print(" ");
     parallel_move()->PrintTo(f);
   }
 }
 
 
 void CatchBlockEntryInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("B%"Pd"[target catch try_idx %"Pd" catch_try_idx %"Pd"]",
+  f->Print("B%" Pd "[target catch try_idx %" Pd " catch_try_idx %" Pd "]",
            block_id(), try_index(), catch_try_index());
   if (HasParallelMove()) {
     f->Print("\n");
     parallel_move()->PrintTo(f);
   }
 
   const GrowableArray<Definition*>& defns = initial_definitions_;
   if (defns.length() > 0) {
     f->Print(" {");
     for (intptr_t i = 0; i < defns.length(); ++i) {
@@ skipping 10 matching lines @@
   value()->PrintTo(f);
 }
 
 
 void GotoInstr::PrintTo(BufferFormatter* f) const {
   if (HasParallelMove()) {
     parallel_move()->PrintTo(f);
     f->Print(" ");
   }
   if (GetDeoptId() != Isolate::kNoDeoptId) {
-    f->Print("goto:%"Pd" %"Pd"", GetDeoptId(), successor()->block_id());
+    f->Print("goto:%" Pd " %" Pd "", GetDeoptId(), successor()->block_id());
   } else {
-    f->Print("goto: %"Pd"", successor()->block_id());
+    f->Print("goto: %" Pd "", successor()->block_id());
   }
 }
 
 
 void BranchInstr::PrintTo(BufferFormatter* f) const {
   f->Print("%s ", DebugName());
   f->Print("if ");
   comparison()->PrintTo(f);
 
-  f->Print(" goto (%"Pd", %"Pd")",
+  f->Print(" goto (%" Pd ", %" Pd ")",
             true_successor()->block_id(),
             false_successor()->block_id());
 }
 
 
 void ParallelMoveInstr::PrintTo(BufferFormatter* f) const {
   f->Print("%s ", DebugName());
   for (intptr_t i = 0; i < moves_.length(); i++) {
     if (i != 0) f->Print(", ");
     moves_[i]->dest().PrintTo(f);
@@ skipping 17 matching lines @@
       f->Print(" [");
       locations_[i].PrintTo(f);
       f->Print("]");
     }
   }
   f->Print(" }");
   if (outer_ != NULL) outer_->PrintTo(f);
 }
 
 }  // namespace dart