1//===--- raw_ostream.h - Raw output stream ----------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the raw_ostream class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_SUPPORT_RAW_OSTREAM_H
14#define LLVM_SUPPORT_RAW_OSTREAM_H
15
16#include "llvm/ADT/SmallVector.h"
17#include "llvm/ADT/StringRef.h"
18#include "llvm/Support/DataTypes.h"
19#include <cassert>
20#include <chrono>
21#include <cstddef>
22#include <cstdint>
23#include <cstring>
24#include <string>
25#include <system_error>
26#include <type_traits>
27
28namespace llvm {
29
30class formatv_object_base;
31class format_object_base;
32class FormattedString;
33class FormattedNumber;
34class FormattedBytes;
35template <class T> class LLVM_NODISCARD Expected;
36
37namespace sys {
38namespace fs {
39enum FileAccess : unsigned;
40enum OpenFlags : unsigned;
41enum CreationDisposition : unsigned;
42class FileLocker;
43} // end namespace fs
44} // end namespace sys
45
46/// This class implements an extremely fast bulk output stream that can *only*
47/// output to a stream. It does not support seeking, reopening, rewinding, line
48/// buffered disciplines etc. It is a simple buffer that outputs
49/// a chunk at a time.
50class raw_ostream {
51public:
52 // Class kinds to support LLVM-style RTTI.
53 enum class OStreamKind {
54 OK_OStream,
55 OK_FDStream,
56 };
57
58private:
59 OStreamKind Kind;
60
61 /// The buffer is handled in such a way that the buffer is
62 /// uninitialized, unbuffered, or out of space when OutBufCur >=
63 /// OutBufEnd. Thus a single comparison suffices to determine if we
64 /// need to take the slow path to write a single character.
65 ///
66 /// The buffer is in one of three states:
67 /// 1. Unbuffered (BufferMode == Unbuffered)
68 /// 1. Uninitialized (BufferMode != Unbuffered && OutBufStart == 0).
69 /// 2. Buffered (BufferMode != Unbuffered && OutBufStart != 0 &&
70 /// OutBufEnd - OutBufStart >= 1).
71 ///
72 /// If buffered, then the raw_ostream owns the buffer if (BufferMode ==
73 /// InternalBuffer); otherwise the buffer has been set via SetBuffer and is
74 /// managed by the subclass.
75 ///
76 /// If a subclass installs an external buffer using SetBuffer then it can wait
77 /// for a \see write_impl() call to handle the data which has been put into
78 /// this buffer.
79 char *OutBufStart, *OutBufEnd, *OutBufCur;
80 bool ColorEnabled = false;
81
82 /// Optional stream this stream is tied to. If this stream is written to, the
83 /// tied-to stream will be flushed first.
84 raw_ostream *TiedStream = nullptr;
85
86 enum class BufferKind {
87 Unbuffered = 0,
88 InternalBuffer,
89 ExternalBuffer
90 } BufferMode;
91
92public:
93 // color order matches ANSI escape sequence, don't change
94 enum class Colors {
95 BLACK = 0,
96 RED,
97 GREEN,
98 YELLOW,
99 BLUE,
100 MAGENTA,
101 CYAN,
102 WHITE,
103 SAVEDCOLOR,
104 RESET,
105 };
106
107 static constexpr Colors BLACK = Colors::BLACK;
108 static constexpr Colors RED = Colors::RED;
109 static constexpr Colors GREEN = Colors::GREEN;
110 static constexpr Colors YELLOW = Colors::YELLOW;
111 static constexpr Colors BLUE = Colors::BLUE;
112 static constexpr Colors MAGENTA = Colors::MAGENTA;
113 static constexpr Colors CYAN = Colors::CYAN;
114 static constexpr Colors WHITE = Colors::WHITE;
115 static constexpr Colors SAVEDCOLOR = Colors::SAVEDCOLOR;
116 static constexpr Colors RESET = Colors::RESET;
117
118 explicit raw_ostream(bool unbuffered = false,
119 OStreamKind K = OStreamKind::OK_OStream)
120 : Kind(K), BufferMode(unbuffered ? BufferKind::Unbuffered
121 : BufferKind::InternalBuffer) {
122 // Start out ready to flush.
123 OutBufStart = OutBufEnd = OutBufCur = nullptr;
124 }
125
126 raw_ostream(const raw_ostream &) = delete;
127 void operator=(const raw_ostream &) = delete;
128
129 virtual ~raw_ostream();
130
131 /// tell - Return the current offset with the file.
132 uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
133
134 OStreamKind get_kind() const { return Kind; }
135
136 //===--------------------------------------------------------------------===//
137 // Configuration Interface
138 //===--------------------------------------------------------------------===//
139
140 /// If possible, pre-allocate \p ExtraSize bytes for stream data.
141 /// i.e. it extends internal buffers to keep additional ExtraSize bytes.
142 /// So that the stream could keep at least tell() + ExtraSize bytes
143 /// without re-allocations. reserveExtraSpace() does not change
144 /// the size/data of the stream.
145 virtual void reserveExtraSpace(uint64_t ExtraSize) {}
146
147 /// Set the stream to be buffered, with an automatically determined buffer
148 /// size.
149 void SetBuffered();
150
151 /// Set the stream to be buffered, using the specified buffer size.
152 void SetBufferSize(size_t Size) {
153 flush();
154 SetBufferAndMode(new char[Size], Size, BufferKind::InternalBuffer);
155 }
156
157 size_t GetBufferSize() const {
158 // If we're supposed to be buffered but haven't actually gotten around
159 // to allocating the buffer yet, return the value that would be used.
160 if (BufferMode != BufferKind::Unbuffered && OutBufStart == nullptr)
161 return preferred_buffer_size();
162
163 // Otherwise just return the size of the allocated buffer.
164 return OutBufEnd - OutBufStart;
165 }
166
167 /// Set the stream to be unbuffered. When unbuffered, the stream will flush
168 /// after every write. This routine will also flush the buffer immediately
169 /// when the stream is being set to unbuffered.
170 void SetUnbuffered() {
171 flush();
172 SetBufferAndMode(nullptr, 0, BufferKind::Unbuffered);
173 }
174
175 size_t GetNumBytesInBuffer() const {
176 return OutBufCur - OutBufStart;
177 }
178
179 //===--------------------------------------------------------------------===//
180 // Data Output Interface
181 //===--------------------------------------------------------------------===//
182
183 void flush() {
184 if (OutBufCur != OutBufStart)
185 flush_nonempty();
186 }
187
188 raw_ostream &operator<<(char C) {
189 if (OutBufCur >= OutBufEnd)
190 return write(C);
191 *OutBufCur++ = C;
192 return *this;
193 }
194
195 raw_ostream &operator<<(unsigned char C) {
196 if (OutBufCur >= OutBufEnd)
197 return write(C);
198 *OutBufCur++ = C;
199 return *this;
200 }
201
202 raw_ostream &operator<<(signed char C) {
203 if (OutBufCur >= OutBufEnd)
204 return write(C);
205 *OutBufCur++ = C;
206 return *this;
207 }
208
209 raw_ostream &operator<<(StringRef Str) {
210 // Inline fast path, particularly for strings with a known length.
211 size_t Size = Str.size();
212
213 // Make sure we can use the fast path.
214 if (Size > (size_t)(OutBufEnd - OutBufCur))
215 return write(Str.data(), Size);
216
217 if (Size) {
218 memcpy(OutBufCur, Str.data(), Size);
219 OutBufCur += Size;
220 }
221 return *this;
222 }
223
224 raw_ostream &operator<<(const char *Str) {
225 // Inline fast path, particularly for constant strings where a sufficiently
226 // smart compiler will simplify strlen.
227
228 return this->operator<<(StringRef(Str));
229 }
230
231 raw_ostream &operator<<(const std::string &Str) {
232 // Avoid the fast path, it would only increase code size for a marginal win.
233 return write(Str.data(), Str.length());
234 }
235
236 raw_ostream &operator<<(const SmallVectorImpl<char> &Str) {
237 return write(Str.data(), Str.size());
238 }
239
240 raw_ostream &operator<<(unsigned long N);
241 raw_ostream &operator<<(long N);
242 raw_ostream &operator<<(unsigned long long N);
243 raw_ostream &operator<<(long long N);
244 raw_ostream &operator<<(const void *P);
245
246 raw_ostream &operator<<(unsigned int N) {
247 return this->operator<<(static_cast<unsigned long>(N));
248 }
249
250 raw_ostream &operator<<(int N) {
251 return this->operator<<(static_cast<long>(N));
252 }
253
254 raw_ostream &operator<<(double N);
255
256 /// Output \p N in hexadecimal, without any prefix or padding.
257 raw_ostream &write_hex(unsigned long long N);
258
259 // Change the foreground color of text.
260 raw_ostream &operator<<(Colors C);
261
262 /// Output a formatted UUID with dash separators.
263 using uuid_t = uint8_t[16];
264 raw_ostream &write_uuid(const uuid_t UUID);
265
266 /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't
267 /// satisfy llvm::isPrint into an escape sequence.
268 raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false);
269
270 raw_ostream &write(unsigned char C);
271 raw_ostream &write(const char *Ptr, size_t Size);
272
273 // Formatted output, see the format() function in Support/Format.h.
274 raw_ostream &operator<<(const format_object_base &Fmt);
275
276 // Formatted output, see the leftJustify() function in Support/Format.h.
277 raw_ostream &operator<<(const FormattedString &);
278
279 // Formatted output, see the formatHex() function in Support/Format.h.
280 raw_ostream &operator<<(const FormattedNumber &);
281
282 // Formatted output, see the formatv() function in Support/FormatVariadic.h.
283 raw_ostream &operator<<(const formatv_object_base &);
284
285 // Formatted output, see the format_bytes() function in Support/Format.h.
286 raw_ostream &operator<<(const FormattedBytes &);
287
288 /// indent - Insert 'NumSpaces' spaces.
289 raw_ostream &indent(unsigned NumSpaces);
290
291 /// write_zeros - Insert 'NumZeros' nulls.
292 raw_ostream &write_zeros(unsigned NumZeros);
293
294 /// Changes the foreground color of text that will be output from this point
295 /// forward.
296 /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
297 /// change only the bold attribute, and keep colors untouched
298 /// @param Bold bold/brighter text, default false
299 /// @param BG if true change the background, default: change foreground
300 /// @returns itself so it can be used within << invocations
301 virtual raw_ostream &changeColor(enum Colors Color, bool Bold = false,
302 bool BG = false);
303
304 /// Resets the colors to terminal defaults. Call this when you are done
305 /// outputting colored text, or before program exit.
306 virtual raw_ostream &resetColor();
307
308 /// Reverses the foreground and background colors.
309 virtual raw_ostream &reverseColor();
310
311 /// This function determines if this stream is connected to a "tty" or
312 /// "console" window. That is, the output would be displayed to the user
313 /// rather than being put on a pipe or stored in a file.
314 virtual bool is_displayed() const { return false; }
315
316 /// This function determines if this stream is displayed and supports colors.
317 /// The result is unaffected by calls to enable_color().
318 virtual bool has_colors() const { return is_displayed(); }
319
320 // Enable or disable colors. Once enable_colors(false) is called,
321 // changeColor() has no effect until enable_colors(true) is called.
322 virtual void enable_colors(bool enable) { ColorEnabled = enable; }
323
324 /// Tie this stream to the specified stream. Replaces any existing tied-to
325 /// stream. Specifying a nullptr unties the stream.
326 void tie(raw_ostream *TieTo) { TiedStream = TieTo; }
327
328 //===--------------------------------------------------------------------===//
329 // Subclass Interface
330 //===--------------------------------------------------------------------===//
331
332private:
333 /// The is the piece of the class that is implemented by subclasses. This
334 /// writes the \p Size bytes starting at
335 /// \p Ptr to the underlying stream.
336 ///
337 /// This function is guaranteed to only be called at a point at which it is
338 /// safe for the subclass to install a new buffer via SetBuffer.
339 ///
340 /// \param Ptr The start of the data to be written. For buffered streams this
341 /// is guaranteed to be the start of the buffer.
342 ///
343 /// \param Size The number of bytes to be written.
344 ///
345 /// \invariant { Size > 0 }
346 virtual void write_impl(const char *Ptr, size_t Size) = 0;
347
348 /// Return the current position within the stream, not counting the bytes
349 /// currently in the buffer.
350 virtual uint64_t current_pos() const = 0;
351
352protected:
353 /// Use the provided buffer as the raw_ostream buffer. This is intended for
354 /// use only by subclasses which can arrange for the output to go directly
355 /// into the desired output buffer, instead of being copied on each flush.
356 void SetBuffer(char *BufferStart, size_t Size) {
357 SetBufferAndMode(BufferStart, Size, BufferKind::ExternalBuffer);
358 }
359
360 /// Return an efficient buffer size for the underlying output mechanism.
361 virtual size_t preferred_buffer_size() const;
362
363 /// Return the beginning of the current stream buffer, or 0 if the stream is
364 /// unbuffered.
365 const char *getBufferStart() const { return OutBufStart; }
366
367 //===--------------------------------------------------------------------===//
368 // Private Interface
369 //===--------------------------------------------------------------------===//
370private:
371 /// Install the given buffer and mode.
372 void SetBufferAndMode(char *BufferStart, size_t Size, BufferKind Mode);
373
374 /// Flush the current buffer, which is known to be non-empty. This outputs the
375 /// currently buffered data and resets the buffer to empty.
376 void flush_nonempty();
377
378 /// Copy data into the buffer. Size must not be greater than the number of
379 /// unused bytes in the buffer.
380 void copy_to_buffer(const char *Ptr, size_t Size);
381
382 /// Compute whether colors should be used and do the necessary work such as
383 /// flushing. The result is affected by calls to enable_color().
384 bool prepare_colors();
385
386 /// Flush the tied-to stream (if present) and then write the required data.
387 void flush_tied_then_write(const char *Ptr, size_t Size);
388
389 virtual void anchor();
390};
391
392/// Call the appropriate insertion operator, given an rvalue reference to a
393/// raw_ostream object and return a stream of the same type as the argument.
394template <typename OStream, typename T>
395std::enable_if_t<!std::is_reference<OStream>::value &&
396 std::is_base_of<raw_ostream, OStream>::value,
397 OStream &&>
398operator<<(OStream &&OS, const T &Value) {
399 OS << Value;
400 return std::move(OS);
401}
402
403/// An abstract base class for streams implementations that also support a
404/// pwrite operation. This is useful for code that can mostly stream out data,
405/// but needs to patch in a header that needs to know the output size.
406class raw_pwrite_stream : public raw_ostream {
407 virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0;
408 void anchor() override;
409
410public:
411 explicit raw_pwrite_stream(bool Unbuffered = false,
412 OStreamKind K = OStreamKind::OK_OStream)
413 : raw_ostream(Unbuffered, K) {}
414 void pwrite(const char *Ptr, size_t Size, uint64_t Offset) {
415#ifndef NDEBUG
416 uint64_t Pos = tell();
417 // /dev/null always reports a pos of 0, so we cannot perform this check
418 // in that case.
419 if (Pos)
420 assert(Size + Offset <= Pos && "We don't support extending the stream");
421#endif
422 pwrite_impl(Ptr, Size, Offset);
423 }
424};
425
426//===----------------------------------------------------------------------===//
427// File Output Streams
428//===----------------------------------------------------------------------===//
429
430/// A raw_ostream that writes to a file descriptor.
431///
432class raw_fd_ostream : public raw_pwrite_stream {
433 int FD;
434 bool ShouldClose;
435 bool SupportsSeeking = false;
436 mutable Optional<bool> HasColors;
437
438#ifdef _WIN32
439 /// True if this fd refers to a Windows console device. Mintty and other
440 /// terminal emulators are TTYs, but they are not consoles.
441 bool IsWindowsConsole = false;
442#endif
443
444 std::error_code EC;
445
446 uint64_t pos = 0;
447
448 /// See raw_ostream::write_impl.
449 void write_impl(const char *Ptr, size_t Size) override;
450
451 void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
452
453 /// Return the current position within the stream, not counting the bytes
454 /// currently in the buffer.
455 uint64_t current_pos() const override { return pos; }
456
457 /// Determine an efficient buffer size.
458 size_t preferred_buffer_size() const override;
459
460 void anchor() override;
461
462protected:
463 /// Set the flag indicating that an output error has been encountered.
464 void error_detected(std::error_code EC) { this->EC = EC; }
465
466 /// Return the file descriptor.
467 int get_fd() const { return FD; }
468
469 // Update the file position by increasing \p Delta.
470 void inc_pos(uint64_t Delta) { pos += Delta; }
471
472public:
473 /// Open the specified file for writing. If an error occurs, information
474 /// about the error is put into EC, and the stream should be immediately
475 /// destroyed;
476 /// \p Flags allows optional flags to control how the file will be opened.
477 ///
478 /// As a special case, if Filename is "-", then the stream will use
479 /// STDOUT_FILENO instead of opening a file. This will not close the stdout
480 /// descriptor.
481 raw_fd_ostream(StringRef Filename, std::error_code &EC);
482 raw_fd_ostream(StringRef Filename, std::error_code &EC,
483 sys::fs::CreationDisposition Disp);
484 raw_fd_ostream(StringRef Filename, std::error_code &EC,
485 sys::fs::FileAccess Access);
486 raw_fd_ostream(StringRef Filename, std::error_code &EC,
487 sys::fs::OpenFlags Flags);
488 raw_fd_ostream(StringRef Filename, std::error_code &EC,
489 sys::fs::CreationDisposition Disp, sys::fs::FileAccess Access,
490 sys::fs::OpenFlags Flags);
491
492 /// FD is the file descriptor that this writes to. If ShouldClose is true,
493 /// this closes the file when the stream is destroyed. If FD is for stdout or
494 /// stderr, it will not be closed.
495 raw_fd_ostream(int fd, bool shouldClose, bool unbuffered = false,
496 OStreamKind K = OStreamKind::OK_OStream);
497
498 ~raw_fd_ostream() override;
499
500 /// Manually flush the stream and close the file. Note that this does not call
501 /// fsync.
502 void close();
503
504 bool supportsSeeking() const { return SupportsSeeking; }
505
506 /// Flushes the stream and repositions the underlying file descriptor position
507 /// to the offset specified from the beginning of the file.
508 uint64_t seek(uint64_t off);
509
510 bool is_displayed() const override;
511
512 bool has_colors() const override;
513
514 std::error_code error() const { return EC; }
515
516 /// Return the value of the flag in this raw_fd_ostream indicating whether an
517 /// output error has been encountered.
518 /// This doesn't implicitly flush any pending output. Also, it doesn't
519 /// guarantee to detect all errors unless the stream has been closed.
520 bool has_error() const { return bool(EC); }
521
522 /// Set the flag read by has_error() to false. If the error flag is set at the
523 /// time when this raw_ostream's destructor is called, report_fatal_error is
524 /// called to report the error. Use clear_error() after handling the error to
525 /// avoid this behavior.
526 ///
527 /// "Errors should never pass silently.
528 /// Unless explicitly silenced."
529 /// - from The Zen of Python, by Tim Peters
530 ///
531 void clear_error() { EC = std::error_code(); }
532
533 /// Locks the underlying file.
534 ///
535 /// @returns RAII object that releases the lock upon leaving the scope, if the
536 /// locking was successful. Otherwise returns corresponding
537 /// error code.
538 ///
539 /// The function blocks the current thread until the lock become available or
540 /// error occurs.
541 ///
542 /// Possible use of this function may be as follows:
543 ///
544 /// @code{.cpp}
545 /// if (auto L = stream.lock()) {
546 /// // ... do action that require file to be locked.
547 /// } else {
548 /// handleAllErrors(std::move(L.takeError()), [&](ErrorInfoBase &EIB) {
549 /// // ... handle lock error.
550 /// });
551 /// }
552 /// @endcode
553 LLVM_NODISCARD Expected<sys::fs::FileLocker> lock();
554
555 /// Tries to lock the underlying file within the specified period.
556 ///
557 /// @returns RAII object that releases the lock upon leaving the scope, if the
558 /// locking was successful. Otherwise returns corresponding
559 /// error code.
560 ///
561 /// It is used as @ref lock.
562 LLVM_NODISCARD
563 Expected<sys::fs::FileLocker> tryLockFor(std::chrono::milliseconds Timeout);
564};
565
566/// This returns a reference to a raw_fd_ostream for standard output. Use it
567/// like: outs() << "foo" << "bar";
568raw_fd_ostream &outs();
569
570/// This returns a reference to a raw_ostream for standard error.
571/// Use it like: errs() << "foo" << "bar";
572/// By default, the stream is tied to stdout to ensure stdout is flushed before
573/// stderr is written, to ensure the error messages are written in their
574/// expected place.
575raw_fd_ostream &errs();
576
577/// This returns a reference to a raw_ostream which simply discards output.
578raw_ostream &nulls();
579
580//===----------------------------------------------------------------------===//
581// File Streams
582//===----------------------------------------------------------------------===//
583
584/// A raw_ostream of a file for reading/writing/seeking.
585///
586class raw_fd_stream : public raw_fd_ostream {
587public:
588 /// Open the specified file for reading/writing/seeking. If an error occurs,
589 /// information about the error is put into EC, and the stream should be
590 /// immediately destroyed.
591 raw_fd_stream(StringRef Filename, std::error_code &EC);
592
593 /// This reads the \p Size bytes into a buffer pointed by \p Ptr.
594 ///
595 /// \param Ptr The start of the buffer to hold data to be read.
596 ///
597 /// \param Size The number of bytes to be read.
598 ///
599 /// On success, the number of bytes read is returned, and the file position is
600 /// advanced by this number. On error, -1 is returned, use error() to get the
601 /// error code.
602 ssize_t read(char *Ptr, size_t Size);
603
604 /// Check if \p OS is a pointer of type raw_fd_stream*.
605 static bool classof(const raw_ostream *OS);
606};
607
608//===----------------------------------------------------------------------===//
609// Output Stream Adaptors
610//===----------------------------------------------------------------------===//
611
612/// A raw_ostream that writes to an std::string. This is a simple adaptor
613/// class. This class does not encounter output errors.
614class raw_string_ostream : public raw_ostream {
615 std::string &OS;
616
617 /// See raw_ostream::write_impl.
618 void write_impl(const char *Ptr, size_t Size) override;
619
620 /// Return the current position within the stream, not counting the bytes
621 /// currently in the buffer.
622 uint64_t current_pos() const override { return OS.size(); }
623
624public:
625 explicit raw_string_ostream(std::string &O) : OS(O) {
626 SetUnbuffered();
627 }
628 ~raw_string_ostream() override;
629
630 /// Flushes the stream contents to the target string and returns the string's
631 /// reference.
632 std::string& str() {
633 flush();
634 return OS;
635 }
636
637 void reserveExtraSpace(uint64_t ExtraSize) override {
638 OS.reserve(tell() + ExtraSize);
639 }
640};
641
642/// A raw_ostream that writes to an SmallVector or SmallString. This is a
643/// simple adaptor class. This class does not encounter output errors.
644/// raw_svector_ostream operates without a buffer, delegating all memory
645/// management to the SmallString. Thus the SmallString is always up-to-date,
646/// may be used directly and there is no need to call flush().
647class raw_svector_ostream : public raw_pwrite_stream {
648 SmallVectorImpl<char> &OS;
649
650 /// See raw_ostream::write_impl.
651 void write_impl(const char *Ptr, size_t Size) override;
652
653 void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
654
655 /// Return the current position within the stream.
656 uint64_t current_pos() const override;
657
658public:
659 /// Construct a new raw_svector_ostream.
660 ///
661 /// \param O The vector to write to; this should generally have at least 128
662 /// bytes free to avoid any extraneous memory overhead.
663 explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
664 SetUnbuffered();
665 }
666
667 ~raw_svector_ostream() override = default;
668
669 void flush() = delete;
670
671 /// Return a StringRef for the vector contents.
672 StringRef str() const { return StringRef(OS.data(), OS.size()); }
673
674 void reserveExtraSpace(uint64_t ExtraSize) override {
675 OS.reserve(tell() + ExtraSize);
676 }
677};
678
679/// A raw_ostream that discards all output.
680class raw_null_ostream : public raw_pwrite_stream {
681 /// See raw_ostream::write_impl.
682 void write_impl(const char *Ptr, size_t size) override;
683 void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
684
685 /// Return the current position within the stream, not counting the bytes
686 /// currently in the buffer.
687 uint64_t current_pos() const override;
688
689public:
690 explicit raw_null_ostream() = default;
691 ~raw_null_ostream() override;
692};
693
694class buffer_ostream : public raw_svector_ostream {
695 raw_ostream &OS;
696 SmallVector<char, 0> Buffer;
697
698 virtual void anchor() override;
699
700public:
701 buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {}
702 ~buffer_ostream() override { OS << str(); }
703};
704
705class buffer_unique_ostream : public raw_svector_ostream {
706 std::unique_ptr<raw_ostream> OS;
707 SmallVector<char, 0> Buffer;
708
709 virtual void anchor() override;
710
711public:
712 buffer_unique_ostream(std::unique_ptr<raw_ostream> OS)
713 : raw_svector_ostream(Buffer), OS(std::move(OS)) {}
714 ~buffer_unique_ostream() override { *OS << str(); }
715};
716
717class Error;
718
719/// This helper creates an output stream and then passes it to \p Write.
720/// The stream created is based on the specified \p OutputFileName:
721/// llvm::outs for "-", raw_null_ostream for "/dev/null", and raw_fd_ostream
722/// for other names. For raw_fd_ostream instances, the stream writes to
723/// a temporary file. The final output file is atomically replaced with the
724/// temporary file after the \p Write function is finished.
725Error writeToOutput(StringRef OutputFileName,
726 std::function<Error(raw_ostream &)> Write);
727
728} // end namespace llvm
729
730#endif // LLVM_SUPPORT_RAW_OSTREAM_H
731