raw_ostream.cpp revision 263508
1//===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This implements support for bulk buffered stream output. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/Support/raw_ostream.h" 15#include "llvm/ADT/STLExtras.h" 16#include "llvm/ADT/SmallVector.h" 17#include "llvm/ADT/StringExtras.h" 18#include "llvm/Config/config.h" 19#include "llvm/Support/Compiler.h" 20#include "llvm/Support/ErrorHandling.h" 21#include "llvm/Support/FileSystem.h" 22#include "llvm/Support/Format.h" 23#include "llvm/Support/Process.h" 24#include "llvm/Support/Program.h" 25#include "llvm/Support/system_error.h" 26#include <cctype> 27#include <cerrno> 28#include <sys/stat.h> 29 30// <fcntl.h> may provide O_BINARY. 31#if defined(HAVE_FCNTL_H) 32# include <fcntl.h> 33#endif 34 35#if defined(HAVE_UNISTD_H) 36# include <unistd.h> 37#endif 38#if defined(HAVE_SYS_UIO_H) && defined(HAVE_WRITEV) 39# include <sys/uio.h> 40#endif 41 42#if defined(__CYGWIN__) 43#include <io.h> 44#endif 45 46#if defined(_MSC_VER) 47#include <io.h> 48#ifndef STDIN_FILENO 49# define STDIN_FILENO 0 50#endif 51#ifndef STDOUT_FILENO 52# define STDOUT_FILENO 1 53#endif 54#ifndef STDERR_FILENO 55# define STDERR_FILENO 2 56#endif 57#endif 58 59using namespace llvm; 60 61raw_ostream::~raw_ostream() { 62 // raw_ostream's subclasses should take care to flush the buffer 63 // in their destructors. 64 assert(OutBufCur == OutBufStart && 65 "raw_ostream destructor called with non-empty buffer!"); 66 67 if (BufferMode == InternalBuffer) 68 delete [] OutBufStart; 69} 70 71// An out of line virtual method to provide a home for the class vtable. 72void raw_ostream::handle() {} 73 74size_t raw_ostream::preferred_buffer_size() const { 75 // BUFSIZ is intended to be a reasonable default. 76 return BUFSIZ; 77} 78 79void raw_ostream::SetBuffered() { 80 // Ask the subclass to determine an appropriate buffer size. 81 if (size_t Size = preferred_buffer_size()) 82 SetBufferSize(Size); 83 else 84 // It may return 0, meaning this stream should be unbuffered. 85 SetUnbuffered(); 86} 87 88void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size, 89 BufferKind Mode) { 90 assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) || 91 (Mode != Unbuffered && BufferStart && Size)) && 92 "stream must be unbuffered or have at least one byte"); 93 // Make sure the current buffer is free of content (we can't flush here; the 94 // child buffer management logic will be in write_impl). 95 assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!"); 96 97 if (BufferMode == InternalBuffer) 98 delete [] OutBufStart; 99 OutBufStart = BufferStart; 100 OutBufEnd = OutBufStart+Size; 101 OutBufCur = OutBufStart; 102 BufferMode = Mode; 103 104 assert(OutBufStart <= OutBufEnd && "Invalid size!"); 105} 106 107raw_ostream &raw_ostream::operator<<(unsigned long N) { 108 // Zero is a special case. 109 if (N == 0) 110 return *this << '0'; 111 112 char NumberBuffer[20]; 113 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 114 char *CurPtr = EndPtr; 115 116 while (N) { 117 *--CurPtr = '0' + char(N % 10); 118 N /= 10; 119 } 120 return write(CurPtr, EndPtr-CurPtr); 121} 122 123raw_ostream &raw_ostream::operator<<(long N) { 124 if (N < 0) { 125 *this << '-'; 126 // Avoid undefined behavior on LONG_MIN with a cast. 127 N = -(unsigned long)N; 128 } 129 130 return this->operator<<(static_cast<unsigned long>(N)); 131} 132 133raw_ostream &raw_ostream::operator<<(unsigned long long N) { 134 // Output using 32-bit div/mod when possible. 135 if (N == static_cast<unsigned long>(N)) 136 return this->operator<<(static_cast<unsigned long>(N)); 137 138 char NumberBuffer[20]; 139 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 140 char *CurPtr = EndPtr; 141 142 while (N) { 143 *--CurPtr = '0' + char(N % 10); 144 N /= 10; 145 } 146 return write(CurPtr, EndPtr-CurPtr); 147} 148 149raw_ostream &raw_ostream::operator<<(long long N) { 150 if (N < 0) { 151 *this << '-'; 152 // Avoid undefined behavior on INT64_MIN with a cast. 153 N = -(unsigned long long)N; 154 } 155 156 return this->operator<<(static_cast<unsigned long long>(N)); 157} 158 159raw_ostream &raw_ostream::write_hex(unsigned long long N) { 160 // Zero is a special case. 161 if (N == 0) 162 return *this << '0'; 163 164 char NumberBuffer[20]; 165 char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 166 char *CurPtr = EndPtr; 167 168 while (N) { 169 uintptr_t x = N % 16; 170 *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10); 171 N /= 16; 172 } 173 174 return write(CurPtr, EndPtr-CurPtr); 175} 176 177raw_ostream &raw_ostream::write_escaped(StringRef Str, 178 bool UseHexEscapes) { 179 for (unsigned i = 0, e = Str.size(); i != e; ++i) { 180 unsigned char c = Str[i]; 181 182 switch (c) { 183 case '\\': 184 *this << '\\' << '\\'; 185 break; 186 case '\t': 187 *this << '\\' << 't'; 188 break; 189 case '\n': 190 *this << '\\' << 'n'; 191 break; 192 case '"': 193 *this << '\\' << '"'; 194 break; 195 default: 196 if (std::isprint(c)) { 197 *this << c; 198 break; 199 } 200 201 // Write out the escaped representation. 202 if (UseHexEscapes) { 203 *this << '\\' << 'x'; 204 *this << hexdigit((c >> 4 & 0xF)); 205 *this << hexdigit((c >> 0) & 0xF); 206 } else { 207 // Always use a full 3-character octal escape. 208 *this << '\\'; 209 *this << char('0' + ((c >> 6) & 7)); 210 *this << char('0' + ((c >> 3) & 7)); 211 *this << char('0' + ((c >> 0) & 7)); 212 } 213 } 214 } 215 216 return *this; 217} 218 219raw_ostream &raw_ostream::operator<<(const void *P) { 220 *this << '0' << 'x'; 221 222 return write_hex((uintptr_t) P); 223} 224 225raw_ostream &raw_ostream::operator<<(double N) { 226#ifdef _WIN32 227 // On MSVCRT and compatible, output of %e is incompatible to Posix 228 // by default. Number of exponent digits should be at least 2. "%+03d" 229 // FIXME: Implement our formatter to here or Support/Format.h! 230 int fpcl = _fpclass(N); 231 232 // negative zero 233 if (fpcl == _FPCLASS_NZ) 234 return *this << "-0.000000e+00"; 235 236 char buf[16]; 237 unsigned len; 238 len = snprintf(buf, sizeof(buf), "%e", N); 239 if (len <= sizeof(buf) - 2) { 240 if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') { 241 int cs = buf[len - 4]; 242 if (cs == '+' || cs == '-') { 243 int c1 = buf[len - 2]; 244 int c0 = buf[len - 1]; 245 if (isdigit(static_cast<unsigned char>(c1)) && 246 isdigit(static_cast<unsigned char>(c0))) { 247 // Trim leading '0': "...e+012" -> "...e+12\0" 248 buf[len - 3] = c1; 249 buf[len - 2] = c0; 250 buf[--len] = 0; 251 } 252 } 253 } 254 return this->operator<<(buf); 255 } 256#endif 257 return this->operator<<(format("%e", N)); 258} 259 260 261 262void raw_ostream::flush_nonempty() { 263 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty."); 264 size_t Length = OutBufCur - OutBufStart; 265 OutBufCur = OutBufStart; 266 write_impl(OutBufStart, Length); 267} 268 269raw_ostream &raw_ostream::write(unsigned char C) { 270 // Group exceptional cases into a single branch. 271 if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) { 272 if (LLVM_UNLIKELY(!OutBufStart)) { 273 if (BufferMode == Unbuffered) { 274 write_impl(reinterpret_cast<char*>(&C), 1); 275 return *this; 276 } 277 // Set up a buffer and start over. 278 SetBuffered(); 279 return write(C); 280 } 281 282 flush_nonempty(); 283 } 284 285 *OutBufCur++ = C; 286 return *this; 287} 288 289raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) { 290 // Group exceptional cases into a single branch. 291 if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) { 292 if (LLVM_UNLIKELY(!OutBufStart)) { 293 if (BufferMode == Unbuffered) { 294 write_impl(Ptr, Size); 295 return *this; 296 } 297 // Set up a buffer and start over. 298 SetBuffered(); 299 return write(Ptr, Size); 300 } 301 302 size_t NumBytes = OutBufEnd - OutBufCur; 303 304 // If the buffer is empty at this point we have a string that is larger 305 // than the buffer. Directly write the chunk that is a multiple of the 306 // preferred buffer size and put the remainder in the buffer. 307 if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) { 308 size_t BytesToWrite = Size - (Size % NumBytes); 309 write_impl(Ptr, BytesToWrite); 310 size_t BytesRemaining = Size - BytesToWrite; 311 if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) { 312 // Too much left over to copy into our buffer. 313 return write(Ptr + BytesToWrite, BytesRemaining); 314 } 315 copy_to_buffer(Ptr + BytesToWrite, BytesRemaining); 316 return *this; 317 } 318 319 // We don't have enough space in the buffer to fit the string in. Insert as 320 // much as possible, flush and start over with the remainder. 321 copy_to_buffer(Ptr, NumBytes); 322 flush_nonempty(); 323 return write(Ptr + NumBytes, Size - NumBytes); 324 } 325 326 copy_to_buffer(Ptr, Size); 327 328 return *this; 329} 330 331void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { 332 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!"); 333 334 // Handle short strings specially, memcpy isn't very good at very short 335 // strings. 336 switch (Size) { 337 case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH 338 case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH 339 case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH 340 case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH 341 case 0: break; 342 default: 343 memcpy(OutBufCur, Ptr, Size); 344 break; 345 } 346 347 OutBufCur += Size; 348} 349 350// Formatted output. 351raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { 352 // If we have more than a few bytes left in our output buffer, try 353 // formatting directly onto its end. 354 size_t NextBufferSize = 127; 355 size_t BufferBytesLeft = OutBufEnd - OutBufCur; 356 if (BufferBytesLeft > 3) { 357 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft); 358 359 // Common case is that we have plenty of space. 360 if (BytesUsed <= BufferBytesLeft) { 361 OutBufCur += BytesUsed; 362 return *this; 363 } 364 365 // Otherwise, we overflowed and the return value tells us the size to try 366 // again with. 367 NextBufferSize = BytesUsed; 368 } 369 370 // If we got here, we didn't have enough space in the output buffer for the 371 // string. Try printing into a SmallVector that is resized to have enough 372 // space. Iterate until we win. 373 SmallVector<char, 128> V; 374 375 while (1) { 376 V.resize(NextBufferSize); 377 378 // Try formatting into the SmallVector. 379 size_t BytesUsed = Fmt.print(V.data(), NextBufferSize); 380 381 // If BytesUsed fit into the vector, we win. 382 if (BytesUsed <= NextBufferSize) 383 return write(V.data(), BytesUsed); 384 385 // Otherwise, try again with a new size. 386 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?"); 387 NextBufferSize = BytesUsed; 388 } 389} 390 391/// indent - Insert 'NumSpaces' spaces. 392raw_ostream &raw_ostream::indent(unsigned NumSpaces) { 393 static const char Spaces[] = " " 394 " " 395 " "; 396 397 // Usually the indentation is small, handle it with a fastpath. 398 if (NumSpaces < array_lengthof(Spaces)) 399 return write(Spaces, NumSpaces); 400 401 while (NumSpaces) { 402 unsigned NumToWrite = std::min(NumSpaces, 403 (unsigned)array_lengthof(Spaces)-1); 404 write(Spaces, NumToWrite); 405 NumSpaces -= NumToWrite; 406 } 407 return *this; 408} 409 410 411//===----------------------------------------------------------------------===// 412// Formatted Output 413//===----------------------------------------------------------------------===// 414 415// Out of line virtual method. 416void format_object_base::home() { 417} 418 419//===----------------------------------------------------------------------===// 420// raw_fd_ostream 421//===----------------------------------------------------------------------===// 422 423/// raw_fd_ostream - Open the specified file for writing. If an error 424/// occurs, information about the error is put into ErrorInfo, and the 425/// stream should be immediately destroyed; the string will be empty 426/// if no error occurred. 427raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo, 428 sys::fs::OpenFlags Flags) 429 : Error(false), UseAtomicWrites(false), pos(0) { 430 assert(Filename != 0 && "Filename is null"); 431 ErrorInfo.clear(); 432 433 // Handle "-" as stdout. Note that when we do this, we consider ourself 434 // the owner of stdout. This means that we can do things like close the 435 // file descriptor when we're done and set the "binary" flag globally. 436 if (Filename[0] == '-' && Filename[1] == 0) { 437 FD = STDOUT_FILENO; 438 // If user requested binary then put stdout into binary mode if 439 // possible. 440 if (Flags & sys::fs::F_Binary) 441 sys::ChangeStdoutToBinary(); 442 // Close stdout when we're done, to detect any output errors. 443 ShouldClose = true; 444 return; 445 } 446 447 error_code EC = sys::fs::openFileForWrite(Filename, FD, Flags); 448 449 if (EC) { 450 ErrorInfo = "Error opening output file '" + std::string(Filename) + "': " + 451 EC.message(); 452 ShouldClose = false; 453 return; 454 } 455 456 // Ok, we successfully opened the file, so it'll need to be closed. 457 ShouldClose = true; 458} 459 460/// raw_fd_ostream ctor - FD is the file descriptor that this writes to. If 461/// ShouldClose is true, this closes the file when the stream is destroyed. 462raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered) 463 : raw_ostream(unbuffered), FD(fd), 464 ShouldClose(shouldClose), Error(false), UseAtomicWrites(false) { 465#ifdef O_BINARY 466 // Setting STDOUT and STDERR to binary mode is necessary in Win32 467 // to avoid undesirable linefeed conversion. 468 if (fd == STDOUT_FILENO || fd == STDERR_FILENO) 469 setmode(fd, O_BINARY); 470#endif 471 472 // Get the starting position. 473 off_t loc = ::lseek(FD, 0, SEEK_CUR); 474 if (loc == (off_t)-1) 475 pos = 0; 476 else 477 pos = static_cast<uint64_t>(loc); 478} 479 480raw_fd_ostream::~raw_fd_ostream() { 481 if (FD >= 0) { 482 flush(); 483 if (ShouldClose) 484 while (::close(FD) != 0) 485 if (errno != EINTR) { 486 error_detected(); 487 break; 488 } 489 } 490 491#ifdef __MINGW32__ 492 // On mingw, global dtors should not call exit(). 493 // report_fatal_error() invokes exit(). We know report_fatal_error() 494 // might not write messages to stderr when any errors were detected 495 // on FD == 2. 496 if (FD == 2) return; 497#endif 498 499 // If there are any pending errors, report them now. Clients wishing 500 // to avoid report_fatal_error calls should check for errors with 501 // has_error() and clear the error flag with clear_error() before 502 // destructing raw_ostream objects which may have errors. 503 if (has_error()) 504 report_fatal_error("IO failure on output stream.", /*GenCrashDiag=*/false); 505} 506 507 508void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { 509 assert(FD >= 0 && "File already closed."); 510 pos += Size; 511 512 do { 513 ssize_t ret; 514 515 // Check whether we should attempt to use atomic writes. 516 if (LLVM_LIKELY(!UseAtomicWrites)) { 517 ret = ::write(FD, Ptr, Size); 518 } else { 519 // Use ::writev() where available. 520#if defined(HAVE_WRITEV) 521 const void *Addr = static_cast<const void *>(Ptr); 522 struct iovec IOV = {const_cast<void *>(Addr), Size }; 523 ret = ::writev(FD, &IOV, 1); 524#else 525 ret = ::write(FD, Ptr, Size); 526#endif 527 } 528 529 if (ret < 0) { 530 // If it's a recoverable error, swallow it and retry the write. 531 // 532 // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since 533 // raw_ostream isn't designed to do non-blocking I/O. However, some 534 // programs, such as old versions of bjam, have mistakenly used 535 // O_NONBLOCK. For compatibility, emulate blocking semantics by 536 // spinning until the write succeeds. If you don't want spinning, 537 // don't use O_NONBLOCK file descriptors with raw_ostream. 538 if (errno == EINTR || errno == EAGAIN 539#ifdef EWOULDBLOCK 540 || errno == EWOULDBLOCK 541#endif 542 ) 543 continue; 544 545 // Otherwise it's a non-recoverable error. Note it and quit. 546 error_detected(); 547 break; 548 } 549 550 // The write may have written some or all of the data. Update the 551 // size and buffer pointer to reflect the remainder that needs 552 // to be written. If there are no bytes left, we're done. 553 Ptr += ret; 554 Size -= ret; 555 } while (Size > 0); 556} 557 558void raw_fd_ostream::close() { 559 assert(ShouldClose); 560 ShouldClose = false; 561 flush(); 562 while (::close(FD) != 0) 563 if (errno != EINTR) { 564 error_detected(); 565 break; 566 } 567 FD = -1; 568} 569 570uint64_t raw_fd_ostream::seek(uint64_t off) { 571 flush(); 572 pos = ::lseek(FD, off, SEEK_SET); 573 if (pos != off) 574 error_detected(); 575 return pos; 576} 577 578size_t raw_fd_ostream::preferred_buffer_size() const { 579#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix) 580 // Windows and Minix have no st_blksize. 581 assert(FD >= 0 && "File not yet open!"); 582 struct stat statbuf; 583 if (fstat(FD, &statbuf) != 0) 584 return 0; 585 586 // If this is a terminal, don't use buffering. Line buffering 587 // would be a more traditional thing to do, but it's not worth 588 // the complexity. 589 if (S_ISCHR(statbuf.st_mode) && isatty(FD)) 590 return 0; 591 // Return the preferred block size. 592 return statbuf.st_blksize; 593#else 594 return raw_ostream::preferred_buffer_size(); 595#endif 596} 597 598raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold, 599 bool bg) { 600 if (sys::Process::ColorNeedsFlush()) 601 flush(); 602 const char *colorcode = 603 (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg) 604 : sys::Process::OutputColor(colors, bold, bg); 605 if (colorcode) { 606 size_t len = strlen(colorcode); 607 write(colorcode, len); 608 // don't account colors towards output characters 609 pos -= len; 610 } 611 return *this; 612} 613 614raw_ostream &raw_fd_ostream::resetColor() { 615 if (sys::Process::ColorNeedsFlush()) 616 flush(); 617 const char *colorcode = sys::Process::ResetColor(); 618 if (colorcode) { 619 size_t len = strlen(colorcode); 620 write(colorcode, len); 621 // don't account colors towards output characters 622 pos -= len; 623 } 624 return *this; 625} 626 627raw_ostream &raw_fd_ostream::reverseColor() { 628 if (sys::Process::ColorNeedsFlush()) 629 flush(); 630 const char *colorcode = sys::Process::OutputReverse(); 631 if (colorcode) { 632 size_t len = strlen(colorcode); 633 write(colorcode, len); 634 // don't account colors towards output characters 635 pos -= len; 636 } 637 return *this; 638} 639 640bool raw_fd_ostream::is_displayed() const { 641 return sys::Process::FileDescriptorIsDisplayed(FD); 642} 643 644bool raw_fd_ostream::has_colors() const { 645 return sys::Process::FileDescriptorHasColors(FD); 646} 647 648//===----------------------------------------------------------------------===// 649// outs(), errs(), nulls() 650//===----------------------------------------------------------------------===// 651 652/// outs() - This returns a reference to a raw_ostream for standard output. 653/// Use it like: outs() << "foo" << "bar"; 654raw_ostream &llvm::outs() { 655 // Set buffer settings to model stdout behavior. 656 // Delete the file descriptor when the program exists, forcing error 657 // detection. If you don't want this behavior, don't use outs(). 658 static raw_fd_ostream S(STDOUT_FILENO, true); 659 return S; 660} 661 662/// errs() - This returns a reference to a raw_ostream for standard error. 663/// Use it like: errs() << "foo" << "bar"; 664raw_ostream &llvm::errs() { 665 // Set standard error to be unbuffered by default. 666 static raw_fd_ostream S(STDERR_FILENO, false, true); 667 return S; 668} 669 670/// nulls() - This returns a reference to a raw_ostream which discards output. 671raw_ostream &llvm::nulls() { 672 static raw_null_ostream S; 673 return S; 674} 675 676 677//===----------------------------------------------------------------------===// 678// raw_string_ostream 679//===----------------------------------------------------------------------===// 680 681raw_string_ostream::~raw_string_ostream() { 682 flush(); 683} 684 685void raw_string_ostream::write_impl(const char *Ptr, size_t Size) { 686 OS.append(Ptr, Size); 687} 688 689//===----------------------------------------------------------------------===// 690// raw_svector_ostream 691//===----------------------------------------------------------------------===// 692 693// The raw_svector_ostream implementation uses the SmallVector itself as the 694// buffer for the raw_ostream. We guarantee that the raw_ostream buffer is 695// always pointing past the end of the vector, but within the vector 696// capacity. This allows raw_ostream to write directly into the correct place, 697// and we only need to set the vector size when the data is flushed. 698 699raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) { 700 // Set up the initial external buffer. We make sure that the buffer has at 701 // least 128 bytes free; raw_ostream itself only requires 64, but we want to 702 // make sure that we don't grow the buffer unnecessarily on destruction (when 703 // the data is flushed). See the FIXME below. 704 OS.reserve(OS.size() + 128); 705 SetBuffer(OS.end(), OS.capacity() - OS.size()); 706} 707 708raw_svector_ostream::~raw_svector_ostream() { 709 // FIXME: Prevent resizing during this flush(). 710 flush(); 711} 712 713/// resync - This is called when the SmallVector we're appending to is changed 714/// outside of the raw_svector_ostream's control. It is only safe to do this 715/// if the raw_svector_ostream has previously been flushed. 716void raw_svector_ostream::resync() { 717 assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector"); 718 719 if (OS.capacity() - OS.size() < 64) 720 OS.reserve(OS.capacity() * 2); 721 SetBuffer(OS.end(), OS.capacity() - OS.size()); 722} 723 724void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { 725 // If we're writing bytes from the end of the buffer into the smallvector, we 726 // don't need to copy the bytes, just commit the bytes because they are 727 // already in the right place. 728 if (Ptr == OS.end()) { 729 assert(OS.size() + Size <= OS.capacity() && "Invalid write_impl() call!"); 730 OS.set_size(OS.size() + Size); 731 } else { 732 assert(GetNumBytesInBuffer() == 0 && 733 "Should be writing from buffer if some bytes in it"); 734 // Otherwise, do copy the bytes. 735 OS.append(Ptr, Ptr+Size); 736 } 737 738 // Grow the vector if necessary. 739 if (OS.capacity() - OS.size() < 64) 740 OS.reserve(OS.capacity() * 2); 741 742 // Update the buffer position. 743 SetBuffer(OS.end(), OS.capacity() - OS.size()); 744} 745 746uint64_t raw_svector_ostream::current_pos() const { 747 return OS.size(); 748} 749 750StringRef raw_svector_ostream::str() { 751 flush(); 752 return StringRef(OS.begin(), OS.size()); 753} 754 755//===----------------------------------------------------------------------===// 756// raw_null_ostream 757//===----------------------------------------------------------------------===// 758 759raw_null_ostream::~raw_null_ostream() { 760#ifndef NDEBUG 761 // ~raw_ostream asserts that the buffer is empty. This isn't necessary 762 // with raw_null_ostream, but it's better to have raw_null_ostream follow 763 // the rules than to change the rules just for raw_null_ostream. 764 flush(); 765#endif 766} 767 768void raw_null_ostream::write_impl(const char *Ptr, size_t Size) { 769} 770 771uint64_t raw_null_ostream::current_pos() const { 772 return 0; 773} 774