Replace OStream with std::ostream.

src/compiler/graph-visualizer.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/graph-visualizer.h"
 
+#include <sstream>
+#include <string>
+
 #include "src/compiler/generic-algorithm.h"
 #include "src/compiler/generic-node.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/ostreams.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 #define DEAD_COLOR "#999999"
 
 class Escaped {
  public:
-  explicit Escaped(const OStringStream& os, const char* escaped_chars = "<>|{}")
-      : str_(os.c_str()), escaped_chars_(escaped_chars) {}
+  explicit Escaped(const std::ostringstream& os,
+                   const char* escaped_chars = "<>|{}")
+      : str_(os.str()), escaped_chars_(escaped_chars) {}
 
-  friend OStream& operator<<(OStream& os, const Escaped& e) {
-    for (const char* s = e.str_; *s != '\0'; ++s) {
-      if (e.needs_escape(*s)) os << "\\";
-      os << *s;
+  friend std::ostream& operator<<(std::ostream& os, const Escaped& e) {
+    for (std::string::const_iterator i = e.str_.begin(); i != e.str_.end();
+         ++i) {
+      if (e.needs_escape(*i)) os << "\\";
+      os << *i;
     }
     return os;
   }
 
  private:
   bool needs_escape(char ch) const {
     for (size_t i = 0; i < strlen(escaped_chars_); ++i) {
       if (ch == escaped_chars_[i]) return true;
     }
     return false;
   }
 
-  const char* const str_;
+  const std::string str_;
   const char* const escaped_chars_;
 };
 
 class JSONGraphNodeWriter : public NullNodeVisitor {
  public:
-  JSONGraphNodeWriter(OStream& os, Zone* zone, const Graph* graph)  // NOLINT
+  JSONGraphNodeWriter(std::ostream& os, Zone* zone,
+                      const Graph* graph)  // NOLINT
       : os_(os),
         graph_(graph),
         first_node_(true) {}
 
   void Print() { const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this); }
 
   GenericGraphVisit::Control Pre(Node* node);
 
  private:
-  OStream& os_;
+  std::ostream& os_;
   const Graph* const graph_;
   bool first_node_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONGraphNodeWriter);
 };
 
 
 GenericGraphVisit::Control JSONGraphNodeWriter::Pre(Node* node) {
   if (first_node_) {
     first_node_ = false;
   } else {
     os_ << ",";
   }
-  OStringStream label;
+  std::ostringstream label;
   label << *node->op();
   os_ << "{\"id\":" << node->id() << ",\"label\":\"" << Escaped(label, "\"")
       << "\"";
   IrOpcode::Value opcode = node->opcode();
   if (opcode == IrOpcode::kPhi || opcode == IrOpcode::kEffectPhi) {
     os_ << ",\"rankInputs\":[0," << NodeProperties::FirstControlIndex(node)
         << "]";
     os_ << ",\"rankWithInput\":[" << NodeProperties::FirstControlIndex(node)
         << "]";
   } else if (opcode == IrOpcode::kIfTrue || opcode == IrOpcode::kIfFalse ||
              opcode == IrOpcode::kLoop) {
     os_ << ",\"rankInputs\":[" << NodeProperties::FirstControlIndex(node)
         << "]";
   }
   if (opcode == IrOpcode::kBranch) {
     os_ << ",\"rankInputs\":[0]";
   }
   os_ << ",\"opcode\":\"" << IrOpcode::Mnemonic(node->opcode()) << "\"";
   os_ << ",\"control\":" << (NodeProperties::IsControl(node) ? "true"
                                                              : "false");
   os_ << "}";
   return GenericGraphVisit::CONTINUE;
 }
 
 
 class JSONGraphEdgeWriter : public NullNodeVisitor {
  public:
-  JSONGraphEdgeWriter(OStream& os, Zone* zone, const Graph* graph)  // NOLINT
+  JSONGraphEdgeWriter(std::ostream& os, Zone* zone,
+                      const Graph* graph)  // NOLINT
       : os_(os),
         graph_(graph),
         first_edge_(true) {}
 
   void Print() { const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this); }
 
   GenericGraphVisit::Control PreEdge(Node* from, int index, Node* to);
 
  private:
-  OStream& os_;
+  std::ostream& os_;
   const Graph* const graph_;
   bool first_edge_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONGraphEdgeWriter);
 };
 
 
 GenericGraphVisit::Control JSONGraphEdgeWriter::PreEdge(Node* from, int index,
                                                         Node* to) {
   if (first_edge_) {
@@ skipping 14 matching lines @@
     edge_type = "effect";
   } else {
     edge_type = "control";
   }
   os_ << "{\"source\":" << to->id() << ",\"target\":" << from->id()
       << ",\"index\":" << index << ",\"type\":\"" << edge_type << "\"}";
   return GenericGraphVisit::CONTINUE;
 }
 
 
-OStream& operator<<(OStream& os, const AsJSON& ad) {
+std::ostream& operator<<(std::ostream& os, const AsJSON& ad) {
   Zone tmp_zone(ad.graph.zone()->isolate());
   os << "{\"nodes\":[";
   JSONGraphNodeWriter(os, &tmp_zone, &ad.graph).Print();
   os << "],\"edges\":[";
   JSONGraphEdgeWriter(os, &tmp_zone, &ad.graph).Print();
   os << "]}";
   return os;
 }
 
 
 class GraphVisualizer : public NullNodeVisitor {
  public:
-  GraphVisualizer(OStream& os, Zone* zone, const Graph* graph);  // NOLINT
+  GraphVisualizer(std::ostream& os, Zone* zone, const Graph* graph);  // NOLINT
 
   void Print();
 
   GenericGraphVisit::Control Pre(Node* node);
   GenericGraphVisit::Control PreEdge(Node* from, int index, Node* to);
 
  private:
   void AnnotateNode(Node* node);
   void PrintEdge(Node::Edge edge);
 
   Zone* zone_;
   NodeSet all_nodes_;
   NodeSet white_nodes_;
   bool use_to_def_;
-  OStream& os_;
+  std::ostream& os_;
   const Graph* const graph_;
 
   DISALLOW_COPY_AND_ASSIGN(GraphVisualizer);
 };
 
 
 static Node* GetControlCluster(Node* node) {
   if (OperatorProperties::IsBasicBlockBegin(node->op())) {
     return node;
   } else if (OperatorProperties::GetControlInputCount(node->op()) == 1) {
@@ skipping 63 matching lines @@
     case IrOpcode::kMerge:
     case IrOpcode::kIfTrue:
     case IrOpcode::kIfFalse:
     case IrOpcode::kLoop:
       os_ << "    style=\"rounded\"\n";
       break;
     default:
       break;
   }
 
-  OStringStream label;
+  std::ostringstream label;
   label << *node->op();
   os_ << "    label=\"{{#" << node->id() << ":" << Escaped(label);
 
   InputIter i = node->inputs().begin();
   for (int j = OperatorProperties::GetValueInputCount(node->op()); j > 0;
        ++i, j--) {
     os_ << "|<I" << i.index() << ">#" << (*i)->id();
   }
   for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
        ++i, j--) {
@@ skipping 12 matching lines @@
       GetControlCluster(node) == NULL) {
     for (int j = OperatorProperties::GetControlInputCount(node->op()); j > 0;
          ++i, j--) {
       os_ << "|<I" << i.index() << ">C #" << (*i)->id();
     }
   }
   os_ << "}";
 
   if (FLAG_trace_turbo_types && !NodeProperties::IsControl(node)) {
     Bounds bounds = NodeProperties::GetBounds(node);
-    OStringStream upper;
+    std::ostringstream upper;
     bounds.upper->PrintTo(upper);
-    OStringStream lower;
+    std::ostringstream lower;
     bounds.lower->PrintTo(lower);
     os_ << "|" << Escaped(upper) << "|" << Escaped(lower);
   }
   os_ << "}\"\n";
 }
 
 
 void GraphVisualizer::PrintEdge(Node::Edge edge) {
   Node* from = edge.from();
   int index = edge.index();
@@ skipping 53 matching lines @@
     Node::Inputs inputs = (*i)->inputs();
     for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
          ++iter) {
       PrintEdge(iter.edge());
     }
   }
   os_ << "}\n";
 }
 
 
-GraphVisualizer::GraphVisualizer(OStream& os, Zone* zone,
+GraphVisualizer::GraphVisualizer(std::ostream& os, Zone* zone,
                                  const Graph* graph)  // NOLINT
     : zone_(zone),
       all_nodes_(NodeSet::key_compare(), NodeSet::allocator_type(zone)),
       white_nodes_(NodeSet::key_compare(), NodeSet::allocator_type(zone)),
       use_to_def_(true),
       os_(os),
       graph_(graph) {}
 
 
-OStream& operator<<(OStream& os, const AsDOT& ad) {
+std::ostream& operator<<(std::ostream& os, const AsDOT& ad) {
   Zone tmp_zone(ad.graph.zone()->isolate());
   GraphVisualizer(os, &tmp_zone, &ad.graph).Print();
   return os;
 }
 }
 }
 }  // namespace v8::internal::compiler