ostreams.h 5.26 KB
Newer Older
1 2 3 4 5 6 7
// 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.

#ifndef V8_OSTREAMS_H_
#define V8_OSTREAMS_H_

8 9 10 11 12
#include <cstddef>
#include <cstdio>
#include <cstring>
#include <ostream>  // NOLINT
#include <streambuf>
13 14 15

#include "include/v8config.h"
#include "src/base/macros.h"
16
#include "src/globals.h"
17 18 19 20

namespace v8 {
namespace internal {

21
class V8_EXPORT_PRIVATE OFStreamBase : public std::streambuf {
svenpanne's avatar
svenpanne committed
22
 public:
23
  explicit OFStreamBase(FILE* f);
24
  ~OFStreamBase() override = default;
25

svenpanne's avatar
svenpanne committed
26
 protected:
27
  FILE* const f_;
28

29 30 31
  int sync() override;
  int_type overflow(int_type c) override;
  std::streamsize xsputn(const char* s, std::streamsize n) override;
32 33
};

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
// Output buffer and stream writing into debugger's command window.
class V8_EXPORT_PRIVATE DbgStreamBuf : public std::streambuf {
 public:
  DbgStreamBuf();
  ~DbgStreamBuf();

 private:
  int sync() override;
  int overflow(int c) override;

  char data_[256];
};

class DbgStdoutStream : public std::ostream {
 public:
  DbgStdoutStream();
  ~DbgStdoutStream() = default;

 private:
  DbgStreamBuf streambuf_;
};

56
// An output stream writing to a file.
57
class V8_EXPORT_PRIVATE OFStream : public std::ostream {
58
 public:
59
  explicit OFStream(FILE* f);
60
  ~OFStream() override = default;
61 62

 private:
svenpanne's avatar
svenpanne committed
63
  OFStreamBase buf_;
64 65
};

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
class V8_EXPORT_PRIVATE AndroidLogStream : public std::streambuf {
 public:
  virtual ~AndroidLogStream();

 protected:
  std::streamsize xsputn(const char* s, std::streamsize n) override;

 private:
  std::string line_buffer_;
};

class StdoutStream : public std::ostream {
 public:
  StdoutStream() : std::ostream(&stream_) {}

 private:
  AndroidLogStream stream_;
};
#else
class StdoutStream : public OFStream {
 public:
  StdoutStream() : OFStream(stdout) {}
};
#endif
91

92
// Wrappers to disambiguate uint16_t and uc16.
93 94 95 96 97 98
struct AsUC16 {
  explicit AsUC16(uint16_t v) : value(v) {}
  uint16_t value;
};


99 100 101 102 103 104
struct AsUC32 {
  explicit AsUC32(int32_t v) : value(v) {}
  int32_t value;
};


105 106 107 108 109
struct AsReversiblyEscapedUC16 {
  explicit AsReversiblyEscapedUC16(uint16_t v) : value(v) {}
  uint16_t value;
};

danno's avatar
danno committed
110 111 112 113 114
struct AsEscapedUC16ForJSON {
  explicit AsEscapedUC16ForJSON(uint16_t v) : value(v) {}
  uint16_t value;
};

115 116 117
// Output the given value as hex, with a minimum width and optional prefix (0x).
// E.g. AsHex(23, 3, true) produces "0x017". Produces an empty string if both
// {min_width} and the value are 0.
118
struct AsHex {
119 120
  explicit AsHex(uint64_t v, uint8_t min_width = 1, bool with_prefix = false)
      : value(v), min_width(min_width), with_prefix(with_prefix) {}
121 122
  uint64_t value;
  uint8_t min_width;
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
  bool with_prefix;
};

// Output the given value as hex, separated in individual bytes.
// E.g. AsHexBytes(0x231712, 4) produces "12 17 23 00" if output as little
// endian (default), and "00 23 17 12" as big endian. Produces an empty string
// if both {min_bytes} and the value are 0.
struct AsHexBytes {
  enum ByteOrder { kLittleEndian, kBigEndian };
  explicit AsHexBytes(uint64_t v, uint8_t min_bytes = 1,
                      ByteOrder byte_order = kLittleEndian)
      : value(v), min_bytes(min_bytes), byte_order(byte_order) {}
  uint64_t value;
  uint8_t min_bytes;
  ByteOrder byte_order;
138
};
139

140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
template <typename T>
struct PrintIteratorRange {
  T start;
  T end;
  PrintIteratorRange(T start, T end) : start(start), end(end) {}
};

// Print any collection which can be iterated via std::begin and std::end.
// {Iterator} is the common type of {std::begin} and {std::end} called on a
// {const T&}. This function is only instantiable if that type exists.
template <typename T, typename Iterator = typename std::common_type<
                          decltype(std::begin(std::declval<const T&>())),
                          decltype(std::end(std::declval<const T&>()))>::type>
PrintIteratorRange<Iterator> PrintCollection(const T& collection) {
  return {std::begin(collection), std::end(collection)};
}

157 158
// Writes the given character to the output escaping everything outside of
// printable/space ASCII range. Additionally escapes '\' making escaping
159
// reversible.
160
std::ostream& operator<<(std::ostream& os, const AsReversiblyEscapedUC16& c);
161

danno's avatar
danno committed
162
// Same as AsReversiblyEscapedUC16 with additional escaping of \n, \r, " and '.
163 164
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                           const AsEscapedUC16ForJSON& c);
danno's avatar
danno committed
165

166 167
// Writes the given character to the output escaping everything outside
// of printable ASCII range.
168 169
std::ostream& operator<<(std::ostream& os, const AsUC16& c);

170 171 172 173
// Writes the given character to the output escaping everything outside
// of printable ASCII range.
std::ostream& operator<<(std::ostream& os, const AsUC32& c);

174 175 176
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, const AsHex& v);
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                           const AsHexBytes& v);
177

178 179 180 181 182 183 184 185 186 187 188
template <typename T>
std::ostream& operator<<(std::ostream& os, const PrintIteratorRange<T>& range) {
  const char* comma = "";
  os << "[";
  for (T it = range.start; it != range.end; ++it, comma = ", ") {
    os << comma << *it;
  }
  os << "]";
  return os;
}

189 190
}  // namespace internal
}  // namespace v8
191 192

#endif  // V8_OSTREAMS_H_