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