V8 API Reference, 7.2.502.16 (for Deno 0.2.4)
ostreams.h
1 // Copyright 2014 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef V8_OSTREAMS_H_
6 #define V8_OSTREAMS_H_
7 
8 #include <cstddef>
9 #include <cstdio>
10 #include <cstring>
11 #include <ostream> // NOLINT
12 #include <streambuf>
13 
14 #include "include/v8config.h"
15 #include "src/base/macros.h"
16 #include "src/globals.h"
17 
18 namespace v8 {
19 namespace internal {
20 
21 class V8_EXPORT_PRIVATE OFStreamBase : public std::streambuf {
22  public:
23  explicit OFStreamBase(FILE* f);
24  ~OFStreamBase() override = default;
25 
26  protected:
27  FILE* const f_;
28 
29  int sync() override;
30  int_type overflow(int_type c) override;
31  std::streamsize xsputn(const char* s, std::streamsize n) override;
32 };
33 
34 // An output stream writing to a file.
35 class V8_EXPORT_PRIVATE OFStream : public std::ostream {
36  public:
37  explicit OFStream(FILE* f);
38  ~OFStream() override = default;
39 
40  private:
41  OFStreamBase buf_;
42 };
43 
44 #if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
45 class V8_EXPORT_PRIVATE AndroidLogStream : public std::streambuf {
46  public:
47  virtual ~AndroidLogStream();
48 
49  protected:
50  std::streamsize xsputn(const char* s, std::streamsize n) override;
51 
52  private:
53  std::string line_buffer_;
54 };
55 
56 class StdoutStream : public std::ostream {
57  public:
58  StdoutStream() : std::ostream(&stream_) {}
59 
60  private:
61  AndroidLogStream stream_;
62 };
63 #else
64 class StdoutStream : public OFStream {
65  public:
66  StdoutStream() : OFStream(stdout) {}
67 };
68 #endif
69 
70 // Wrappers to disambiguate uint16_t and uc16.
71 struct AsUC16 {
72  explicit AsUC16(uint16_t v) : value(v) {}
73  uint16_t value;
74 };
75 
76 
77 struct AsUC32 {
78  explicit AsUC32(int32_t v) : value(v) {}
79  int32_t value;
80 };
81 
82 
84  explicit AsReversiblyEscapedUC16(uint16_t v) : value(v) {}
85  uint16_t value;
86 };
87 
89  explicit AsEscapedUC16ForJSON(uint16_t v) : value(v) {}
90  uint16_t value;
91 };
92 
93 // Output the given value as hex, with a minimum width and optional prefix (0x).
94 // E.g. AsHex(23, 3, true) produces "0x017". Produces an empty string if both
95 // {min_width} and the value are 0.
96 struct AsHex {
97  explicit AsHex(uint64_t v, uint8_t min_width = 1, bool with_prefix = false)
98  : value(v), min_width(min_width), with_prefix(with_prefix) {}
99  uint64_t value;
100  uint8_t min_width;
101  bool with_prefix;
102 };
103 
104 // Output the given value as hex, separated in individual bytes.
105 // E.g. AsHexBytes(0x231712, 4) produces "12 17 23 00" if output as little
106 // endian (default), and "00 23 17 12" as big endian. Produces an empty string
107 // if both {min_bytes} and the value are 0.
108 struct AsHexBytes {
109  enum ByteOrder { kLittleEndian, kBigEndian };
110  explicit AsHexBytes(uint64_t v, uint8_t min_bytes = 1,
111  ByteOrder byte_order = kLittleEndian)
112  : value(v), min_bytes(min_bytes), byte_order(byte_order) {}
113  uint64_t value;
114  uint8_t min_bytes;
115  ByteOrder byte_order;
116 };
117 
118 template <typename T>
120  T start;
121  T end;
122  PrintIteratorRange(T start, T end) : start(start), end(end) {}
123 };
124 
125 // Print any collection which can be iterated via std::begin and std::end.
126 // {Iterator} is the common type of {std::begin} and {std::end} called on a
127 // {const T&}. This function is only instantiable if that type exists.
128 template <typename T, typename Iterator = typename std::common_type<
129  decltype(std::begin(std::declval<const T&>())),
130  decltype(std::end(std::declval<const T&>()))>::type>
131 PrintIteratorRange<Iterator> PrintCollection(const T& collection) {
132  return {std::begin(collection), std::end(collection)};
133 }
134 
135 // Writes the given character to the output escaping everything outside of
136 // printable/space ASCII range. Additionally escapes '\' making escaping
137 // reversible.
138 std::ostream& operator<<(std::ostream& os, const AsReversiblyEscapedUC16& c);
139 
140 // Same as AsReversiblyEscapedUC16 with additional escaping of \n, \r, " and '.
141 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
142  const AsEscapedUC16ForJSON& c);
143 
144 // Writes the given character to the output escaping everything outside
145 // of printable ASCII range.
146 std::ostream& operator<<(std::ostream& os, const AsUC16& c);
147 
148 // Writes the given character to the output escaping everything outside
149 // of printable ASCII range.
150 std::ostream& operator<<(std::ostream& os, const AsUC32& c);
151 
152 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, const AsHex& v);
153 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
154  const AsHexBytes& v);
155 
156 template <typename T>
157 std::ostream& operator<<(std::ostream& os, const PrintIteratorRange<T>& range) {
158  const char* comma = "";
159  os << "[";
160  for (T it = range.start; it != range.end; ++it, comma = ", ") {
161  os << comma << *it;
162  }
163  os << "]";
164  return os;
165 }
166 
167 } // namespace internal
168 } // namespace v8
169 
170 #endif // V8_OSTREAMS_H_
STL namespace.
Definition: libplatform.h:13