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