Added slim versions of output streams.

src/ostreams.cc

Index: src/ostreams.cc
diff --git a/src/ostreams.cc b/src/ostreams.cc
new file mode 100644
index 0000000000000000000000000000000000000000..85dca572a1353abaaaf00caa40e129d3449fd50c
--- /dev/null
+++ b/src/ostreams.cc
@@ -0,0 +1,155 @@
+// Copyright 2014 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 <algorithm>
+
+#include "src/ostreams.h"
+
+#if V8_CC_MSVC
+#define snprintf sprintf_s

[Michael Starzinger, 2014/06/25 22:00:57]

Can we use SNPrintF from utils.h instead of using compiler-specific #ifdef's
here?

[Sven Panne, 2014/06/26 06:56:19]

I intentionally avoided OS::SNPrintF because we increase dependecies for no good
reason. I think that src/base might be an even better place for ostreams.{cc,h},
so it's important to keep dependencies simple and don't introduce any cycles.

One could even go as far as using _MSC_VER directly, nuke the few V8_OVERRIDEs
and expand the (trivial) DISALLOW_COPY_AND_ASSIGNs by hand to get something
totally v8-independent, which would be nice (and is what I would have done
personally). But I wanted to avoid lengthy discussions... ;-)

+#endif
+
+namespace v8 {
+namespace internal {
+
+// Be lazy and delegate the value=>char conversion to snprintf.
+template<class T>
+OStream& OStream::print(const char* format, T x) {
+  char buf[32];
+  int n = snprintf(buf, sizeof(buf), format, x);
+  return (n < 0) ? *this : write(buf, n);
+}
+
+
+OStream& OStream::operator<<(int x) {
+  return print(hex_ ? "%x" : "%d", x);
+}
+
+
+OStream& OStream::operator<<(unsigned int x) {
+  return print(hex_ ? "%x" : "%u", x);
+}
+
+
+OStream& OStream::operator<<(long x) {  // NOLINT(runtime/int)
+  return print(hex_ ? "%lx" : "%ld", x);
+}
+
+
+OStream& OStream::operator<<(unsigned long x) {  // NOLINT(runtime/int)
+  return print(hex_ ? "%lx" : "%lu", x);
+}
+
+
+OStream& OStream::operator<<(long long x) {  // NOLINT(runtime/int)
+  return print(hex_ ? "%llx" : "%lld", x);
+}
+
+
+OStream& OStream::operator<<(unsigned long long x) {  // NOLINT(runtime/int)
+  return print(hex_ ? "%llx" : "%llu", x);
+}
+
+
+OStream& OStream::operator<<(double x) {
+  return print("%g", x);
+}
+
+
+OStream& OStream::operator<<(void* x) {
+  return print("%p", x);
+}
+
+
+OStream& OStream::operator<<(char x) {
+  return put(x);
+}
+
+
+OStream& OStream::operator<<(signed char x) {
+  return put(x);
+}
+
+
+OStream& OStream::operator<<(unsigned char x) {
+  return put(x);
+}
+
+
+OStream& OStream::dec() {
+  hex_ = false;
+  return *this;
+}
+
+
+OStream& OStream::hex() {
+  hex_ = true;
+  return *this;
+}
+
+
+OStream& flush(OStream& os) {  // NOLINT(runtime/references)
+  return os.flush();
+}
+
+
+OStream& endl(OStream& os) {  // NOLINT(runtime/references)
+  return flush(os.put('\n'));
+}
+
+
+OStream& hex(OStream& os) {  // NOLINT(runtime/references)
+  return os.hex();
+}
+
+
+OStream& dec(OStream& os) {  // NOLINT(runtime/references)
+  return os.dec();
+}
+
+
+OStringStream& OStringStream::write(const char* s, size_t n) {
+  size_t new_size = size_ + n;
+  if (new_size < size_) return *this;  // Overflow => no-op.
+  reserve(new_size);
+  memcpy(data_ + size_, s, n);
+  size_ = new_size;
+  return *this;
+}
+
+
+OStringStream& OStringStream::flush() {
+  return *this;
+}
+
+
+void OStringStream::reserve(size_t requested_capacity) {
+  if (requested_capacity <= capacity_) return;
+  size_t new_capacity =  // Handle possible overflow by not doubling.
+      std::max(std::max(capacity_ * 2, capacity_), requested_capacity);
+  char * new_data = allocate(new_capacity);
+  memcpy(new_data, data_, size_);
+  deallocate(data_, capacity_);
+  capacity_ = new_capacity;
+  data_ = new_data;
+}
+
+
+void OFStream::close() {
+  if (own_ && f_) fclose(f_);
+}
+
+
+OFStream& OFStream::write(const char* s, size_t n) {
+  if (f_) fwrite(s, n, 1, f_);
+  return *this;
+}
+
+
+OFStream& OFStream::flush() {
+  if (f_) fflush(f_);
+  return *this;
+}
+
+} }  // namespace v8::internal