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 OFStreamBase : public std::streambuf {
22 public:
23 explicit OFStreamBase(FILE* f);
24 virtual ~OFStreamBase();
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 virtual ~OFStream();
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:
StdoutStream()58 StdoutStream() : std::ostream(&stream_) {}
59
60 private:
61 AndroidLogStream stream_;
62 };
63 #else
64 class StdoutStream : public OFStream {
65 public:
StdoutStream()66 StdoutStream() : OFStream(stdout) {}
67 };
68 #endif
69
70 // Wrappers to disambiguate uint16_t and uc16.
71 struct AsUC16 {
AsUC16AsUC1672 explicit AsUC16(uint16_t v) : value(v) {}
73 uint16_t value;
74 };
75
76
77 struct AsUC32 {
AsUC32AsUC3278 explicit AsUC32(int32_t v) : value(v) {}
79 int32_t value;
80 };
81
82
83 struct AsReversiblyEscapedUC16 {
AsReversiblyEscapedUC16AsReversiblyEscapedUC1684 explicit AsReversiblyEscapedUC16(uint16_t v) : value(v) {}
85 uint16_t value;
86 };
87
88 struct AsEscapedUC16ForJSON {
AsEscapedUC16ForJSONAsEscapedUC16ForJSON89 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)
valueAsHex98 : 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)
valueAsHexBytes112 : 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>
119 struct PrintIteratorRange {
120 T start;
121 T end;
PrintIteratorRangePrintIteratorRange122 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>
PrintCollection(const T & collection)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_
171