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