raw_ostream.cpp revision 226890
12061Sjkh//===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===// 23029Srgrimes// 32061Sjkh// The LLVM Compiler Infrastructure 42061Sjkh// 52061Sjkh// This file is distributed under the University of Illinois Open Source 62061Sjkh// License. See LICENSE.TXT for details. 72061Sjkh// 82061Sjkh//===----------------------------------------------------------------------===// 92160Scsgr// 102160Scsgr// This implements support for bulk buffered stream output. 112834Swollman// 122061Sjkh//===----------------------------------------------------------------------===// 132061Sjkh 142160Scsgr#include "llvm/Support/raw_ostream.h" 152626Scsgr#include "llvm/Support/Format.h" 162061Sjkh#include "llvm/Support/Program.h" 172160Scsgr#include "llvm/Support/Process.h" 181594Srgrimes#include "llvm/ADT/StringExtras.h" 192061Sjkh#include "llvm/ADT/SmallVector.h" 202160Scsgr#include "llvm/Config/config.h" 212061Sjkh#include "llvm/Support/Compiler.h" 221594Srgrimes#include "llvm/Support/ErrorHandling.h" 232061Sjkh#include "llvm/ADT/STLExtras.h" 242061Sjkh#include <cctype> 252061Sjkh#include <cerrno> 262061Sjkh#include <sys/stat.h> 272061Sjkh#include <sys/types.h> 282061Sjkh 292061Sjkh#if defined(HAVE_UNISTD_H) 303029Srgrimes# include <unistd.h> 313029Srgrimes#endif 322061Sjkh#if defined(HAVE_FCNTL_H) 332061Sjkh# include <fcntl.h> 342061Sjkh#endif 352061Sjkh#if defined(HAVE_SYS_UIO_H) && defined(HAVE_WRITEV) 362061Sjkh# include <sys/uio.h> 372061Sjkh#endif 382061Sjkh 392061Sjkh#if defined(__CYGWIN__) 402061Sjkh#include <io.h> 412061Sjkh#endif 422061Sjkh 432061Sjkh#if defined(_MSC_VER) 442061Sjkh#include <io.h> 452160Scsgr#include <fcntl.h> 462061Sjkh#ifndef STDIN_FILENO 472061Sjkh# define STDIN_FILENO 0 482626Scsgr#endif 492626Scsgr#ifndef STDOUT_FILENO 502626Scsgr# define STDOUT_FILENO 1 512626Scsgr#endif 522061Sjkh#ifndef STDERR_FILENO 532061Sjkh# define STDERR_FILENO 2 542061Sjkh#endif 552061Sjkh#endif 562061Sjkh 572061Sjkhusing namespace llvm; 582061Sjkh 592061Sjkhraw_ostream::~raw_ostream() { 602061Sjkh // raw_ostream's subclasses should take care to flush the buffer 612061Sjkh // in their destructors. 622061Sjkh assert(OutBufCur == OutBufStart && 632061Sjkh "raw_ostream destructor called with non-empty buffer!"); 642061Sjkh 652061Sjkh if (BufferMode == InternalBuffer) 662061Sjkh delete [] OutBufStart; 672061Sjkh} 682061Sjkh 692061Sjkh// An out of line virtual method to provide a home for the class vtable. 702834Swollmanvoid raw_ostream::handle() {} 712834Swollman 722834Swollmansize_t raw_ostream::preferred_buffer_size() const { 732834Swollman // BUFSIZ is intended to be a reasonable default. 742834Swollman return BUFSIZ; 752834Swollman} 761594Srgrimes 772061Sjkhvoid raw_ostream::SetBuffered() { 782061Sjkh // Ask the subclass to determine an appropriate buffer size. 792061Sjkh if (size_t Size = preferred_buffer_size()) 802061Sjkh SetBufferSize(Size); 812061Sjkh else 822061Sjkh // It may return 0, meaning this stream should be unbuffered. 832061Sjkh SetUnbuffered(); 842061Sjkh} 852061Sjkh 862061Sjkhvoid raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size, 872061Sjkh BufferKind Mode) { 882061Sjkh assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) || 892061Sjkh (Mode != Unbuffered && BufferStart && Size)) && 902061Sjkh "stream must be unbuffered or have at least one byte"); 912061Sjkh // Make sure the current buffer is free of content (we can't flush here; the 922061Sjkh // child buffer management logic will be in write_impl). 932061Sjkh assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!"); 942061Sjkh 952061Sjkh if (BufferMode == InternalBuffer) 962061Sjkh delete [] OutBufStart; 972061Sjkh OutBufStart = BufferStart; 983029Srgrimes OutBufEnd = OutBufStart+Size; 992061Sjkh OutBufCur = OutBufStart; 1002061Sjkh BufferMode = Mode; 1012061Sjkh 1022061Sjkh assert(OutBufStart <= OutBufEnd && "Invalid size!"); 1032061Sjkh} 1042061Sjkh 1052061Sjkhraw_ostream &raw_ostream::operator<<(unsigned long N) { 1062302Spaul // Zero is a special case. 1073029Srgrimes if (N == 0) 1082061Sjkh return *this << '0'; 1093029Srgrimes 1102061Sjkh char NumberBuffer[20]; 1113029Srgrimes char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 1122061Sjkh char *CurPtr = EndPtr; 1132302Spaul 1142302Spaul while (N) { 1152302Spaul *--CurPtr = '0' + char(N % 10); 1162302Spaul N /= 10; 1172302Spaul } 1182302Spaul return write(CurPtr, EndPtr-CurPtr); 1192302Spaul} 1202302Spaul 1212302Spaulraw_ostream &raw_ostream::operator<<(long N) { 1222302Spaul if (N < 0) { 1232302Spaul *this << '-'; 1242302Spaul // Avoid undefined behavior on LONG_MIN with a cast. 1252302Spaul N = -(unsigned long)N; 1262302Spaul } 1272061Sjkh 1282061Sjkh return this->operator<<(static_cast<unsigned long>(N)); 1292061Sjkh} 1302061Sjkh 1312061Sjkhraw_ostream &raw_ostream::operator<<(unsigned long long N) { 1322061Sjkh // Output using 32-bit div/mod when possible. 1332061Sjkh if (N == static_cast<unsigned long>(N)) 1342061Sjkh return this->operator<<(static_cast<unsigned long>(N)); 1352061Sjkh 1362061Sjkh char NumberBuffer[20]; 1372061Sjkh char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 1382061Sjkh char *CurPtr = EndPtr; 1392061Sjkh 1402061Sjkh while (N) { 1412061Sjkh *--CurPtr = '0' + char(N % 10); 1422061Sjkh N /= 10; 1432061Sjkh } 1442061Sjkh return write(CurPtr, EndPtr-CurPtr); 1452061Sjkh} 1462061Sjkh 1472061Sjkhraw_ostream &raw_ostream::operator<<(long long N) { 1482061Sjkh if (N < 0) { 1492061Sjkh *this << '-'; 1502061Sjkh // Avoid undefined behavior on INT64_MIN with a cast. 1512061Sjkh N = -(unsigned long long)N; 1522061Sjkh } 1532061Sjkh 1542061Sjkh return this->operator<<(static_cast<unsigned long long>(N)); 1552061Sjkh} 1562061Sjkh 1572061Sjkhraw_ostream &raw_ostream::write_hex(unsigned long long N) { 1582061Sjkh // Zero is a special case. 1592061Sjkh if (N == 0) 1602061Sjkh return *this << '0'; 1612061Sjkh 1622061Sjkh char NumberBuffer[20]; 1632061Sjkh char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 1642061Sjkh char *CurPtr = EndPtr; 1652061Sjkh 1662061Sjkh while (N) { 1672061Sjkh uintptr_t x = N % 16; 1682061Sjkh *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10); 1692061Sjkh N /= 16; 1702061Sjkh } 1712685Srgrimes 1722685Srgrimes return write(CurPtr, EndPtr-CurPtr); 1732626Scsgr} 1742061Sjkh 1752061Sjkhraw_ostream &raw_ostream::write_escaped(StringRef Str, 1762061Sjkh bool UseHexEscapes) { 1772061Sjkh for (unsigned i = 0, e = Str.size(); i != e; ++i) { 1782061Sjkh unsigned char c = Str[i]; 1792883Sphk 1802061Sjkh switch (c) { 1812626Scsgr case '\\': 1822626Scsgr *this << '\\' << '\\'; 1832626Scsgr break; 1842626Scsgr case '\t': 1852061Sjkh *this << '\\' << 't'; 1862061Sjkh break; 1872061Sjkh case '\n': 1882061Sjkh *this << '\\' << 'n'; 1892061Sjkh break; 1902061Sjkh case '"': 1912061Sjkh *this << '\\' << '"'; 1922061Sjkh break; 1932061Sjkh default: 1942061Sjkh if (std::isprint(c)) { 1952468Spaul *this << c; 1962061Sjkh break; 1972273Spaul } 1982061Sjkh 1992160Scsgr // Write out the escaped representation. 2002160Scsgr if (UseHexEscapes) { 2012160Scsgr *this << '\\' << 'x'; 2022160Scsgr *this << hexdigit((c >> 4 & 0xF)); 2032279Spaul *this << hexdigit((c >> 0) & 0xF); 2042061Sjkh } else { 2052061Sjkh // Always use a full 3-character octal escape. 2062279Spaul *this << '\\'; 2072468Spaul *this << char('0' + ((c >> 6) & 7)); 2082468Spaul *this << char('0' + ((c >> 3) & 7)); 2092626Scsgr *this << char('0' + ((c >> 0) & 7)); 2102061Sjkh } 2112061Sjkh } 2122061Sjkh } 2132061Sjkh 2142061Sjkh return *this; 2152061Sjkh} 2162061Sjkh 2172061Sjkhraw_ostream &raw_ostream::operator<<(const void *P) { 2182061Sjkh *this << '0' << 'x'; 2192626Scsgr 2202626Scsgr return write_hex((uintptr_t) P); 2212626Scsgr} 2222626Scsgr 2232626Scsgrraw_ostream &raw_ostream::operator<<(double N) { 2242626Scsgr#ifdef _WIN32 2252626Scsgr // On MSVCRT and compatible, output of %e is incompatible to Posix 2262626Scsgr // by default. Number of exponent digits should be at least 2. "%+03d" 2272626Scsgr // FIXME: Implement our formatter to here or Support/Format.h! 2282626Scsgr int fpcl = _fpclass(N); 2292626Scsgr 2302061Sjkh // negative zero 2312061Sjkh if (fpcl == _FPCLASS_NZ) 2322061Sjkh return *this << "-0.000000e+00"; 2332061Sjkh 2342061Sjkh char buf[16]; 2352061Sjkh unsigned len; 2362273Spaul len = snprintf(buf, sizeof(buf), "%e", N); 2372061Sjkh if (len <= sizeof(buf) - 2) { 2382061Sjkh if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') { 2392061Sjkh int cs = buf[len - 4]; 2402061Sjkh if (cs == '+' || cs == '-') { 2411594Srgrimes int c1 = buf[len - 2]; 242 int c0 = buf[len - 1]; 243 if (isdigit(c1) && isdigit(c0)) { 244 // Trim leading '0': "...e+012" -> "...e+12\0" 245 buf[len - 3] = c1; 246 buf[len - 2] = c0; 247 buf[--len] = 0; 248 } 249 } 250 } 251 return this->operator<<(buf); 252 } 253#endif 254 return this->operator<<(format("%e", N)); 255} 256 257 258 259void raw_ostream::flush_nonempty() { 260 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty."); 261 size_t Length = OutBufCur - OutBufStart; 262 OutBufCur = OutBufStart; 263 write_impl(OutBufStart, Length); 264} 265 266raw_ostream &raw_ostream::write(unsigned char C) { 267 // Group exceptional cases into a single branch. 268 if (BUILTIN_EXPECT(OutBufCur >= OutBufEnd, false)) { 269 if (BUILTIN_EXPECT(!OutBufStart, false)) { 270 if (BufferMode == Unbuffered) { 271 write_impl(reinterpret_cast<char*>(&C), 1); 272 return *this; 273 } 274 // Set up a buffer and start over. 275 SetBuffered(); 276 return write(C); 277 } 278 279 flush_nonempty(); 280 } 281 282 *OutBufCur++ = C; 283 return *this; 284} 285 286raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) { 287 // Group exceptional cases into a single branch. 288 if (BUILTIN_EXPECT(size_t(OutBufEnd - OutBufCur) < Size, false)) { 289 if (BUILTIN_EXPECT(!OutBufStart, false)) { 290 if (BufferMode == Unbuffered) { 291 write_impl(Ptr, Size); 292 return *this; 293 } 294 // Set up a buffer and start over. 295 SetBuffered(); 296 return write(Ptr, Size); 297 } 298 299 size_t NumBytes = OutBufEnd - OutBufCur; 300 301 // If the buffer is empty at this point we have a string that is larger 302 // than the buffer. Directly write the chunk that is a multiple of the 303 // preferred buffer size and put the remainder in the buffer. 304 if (BUILTIN_EXPECT(OutBufCur == OutBufStart, false)) { 305 size_t BytesToWrite = Size - (Size % NumBytes); 306 write_impl(Ptr, BytesToWrite); 307 copy_to_buffer(Ptr + BytesToWrite, Size - BytesToWrite); 308 return *this; 309 } 310 311 // We don't have enough space in the buffer to fit the string in. Insert as 312 // much as possible, flush and start over with the remainder. 313 copy_to_buffer(Ptr, NumBytes); 314 flush_nonempty(); 315 return write(Ptr + NumBytes, Size - NumBytes); 316 } 317 318 copy_to_buffer(Ptr, Size); 319 320 return *this; 321} 322 323void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { 324 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!"); 325 326 // Handle short strings specially, memcpy isn't very good at very short 327 // strings. 328 switch (Size) { 329 case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH 330 case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH 331 case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH 332 case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH 333 case 0: break; 334 default: 335 memcpy(OutBufCur, Ptr, Size); 336 break; 337 } 338 339 OutBufCur += Size; 340} 341 342// Formatted output. 343raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { 344 // If we have more than a few bytes left in our output buffer, try 345 // formatting directly onto its end. 346 size_t NextBufferSize = 127; 347 size_t BufferBytesLeft = OutBufEnd - OutBufCur; 348 if (BufferBytesLeft > 3) { 349 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft); 350 351 // Common case is that we have plenty of space. 352 if (BytesUsed <= BufferBytesLeft) { 353 OutBufCur += BytesUsed; 354 return *this; 355 } 356 357 // Otherwise, we overflowed and the return value tells us the size to try 358 // again with. 359 NextBufferSize = BytesUsed; 360 } 361 362 // If we got here, we didn't have enough space in the output buffer for the 363 // string. Try printing into a SmallVector that is resized to have enough 364 // space. Iterate until we win. 365 SmallVector<char, 128> V; 366 367 while (1) { 368 V.resize(NextBufferSize); 369 370 // Try formatting into the SmallVector. 371 size_t BytesUsed = Fmt.print(V.data(), NextBufferSize); 372 373 // If BytesUsed fit into the vector, we win. 374 if (BytesUsed <= NextBufferSize) 375 return write(V.data(), BytesUsed); 376 377 // Otherwise, try again with a new size. 378 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?"); 379 NextBufferSize = BytesUsed; 380 } 381} 382 383/// indent - Insert 'NumSpaces' spaces. 384raw_ostream &raw_ostream::indent(unsigned NumSpaces) { 385 static const char Spaces[] = " " 386 " " 387 " "; 388 389 // Usually the indentation is small, handle it with a fastpath. 390 if (NumSpaces < array_lengthof(Spaces)) 391 return write(Spaces, NumSpaces); 392 393 while (NumSpaces) { 394 unsigned NumToWrite = std::min(NumSpaces, 395 (unsigned)array_lengthof(Spaces)-1); 396 write(Spaces, NumToWrite); 397 NumSpaces -= NumToWrite; 398 } 399 return *this; 400} 401 402 403//===----------------------------------------------------------------------===// 404// Formatted Output 405//===----------------------------------------------------------------------===// 406 407// Out of line virtual method. 408void format_object_base::home() { 409} 410 411//===----------------------------------------------------------------------===// 412// raw_fd_ostream 413//===----------------------------------------------------------------------===// 414 415/// raw_fd_ostream - Open the specified file for writing. If an error 416/// occurs, information about the error is put into ErrorInfo, and the 417/// stream should be immediately destroyed; the string will be empty 418/// if no error occurred. 419raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo, 420 unsigned Flags) 421 : Error(false), UseAtomicWrites(false), pos(0) 422{ 423 assert(Filename != 0 && "Filename is null"); 424 // Verify that we don't have both "append" and "excl". 425 assert((!(Flags & F_Excl) || !(Flags & F_Append)) && 426 "Cannot specify both 'excl' and 'append' file creation flags!"); 427 428 ErrorInfo.clear(); 429 430 // Handle "-" as stdout. Note that when we do this, we consider ourself 431 // the owner of stdout. This means that we can do things like close the 432 // file descriptor when we're done and set the "binary" flag globally. 433 if (Filename[0] == '-' && Filename[1] == 0) { 434 FD = STDOUT_FILENO; 435 // If user requested binary then put stdout into binary mode if 436 // possible. 437 if (Flags & F_Binary) 438 sys::Program::ChangeStdoutToBinary(); 439 // Close stdout when we're done, to detect any output errors. 440 ShouldClose = true; 441 return; 442 } 443 444 int OpenFlags = O_WRONLY|O_CREAT; 445#ifdef O_BINARY 446 if (Flags & F_Binary) 447 OpenFlags |= O_BINARY; 448#endif 449 450 if (Flags & F_Append) 451 OpenFlags |= O_APPEND; 452 else 453 OpenFlags |= O_TRUNC; 454 if (Flags & F_Excl) 455 OpenFlags |= O_EXCL; 456 457 while ((FD = open(Filename, OpenFlags, 0664)) < 0) { 458 if (errno != EINTR) { 459 ErrorInfo = "Error opening output file '" + std::string(Filename) + "'"; 460 ShouldClose = false; 461 return; 462 } 463 } 464 465 // Ok, we successfully opened the file, so it'll need to be closed. 466 ShouldClose = true; 467} 468 469/// raw_fd_ostream ctor - FD is the file descriptor that this writes to. If 470/// ShouldClose is true, this closes the file when the stream is destroyed. 471raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered) 472 : raw_ostream(unbuffered), FD(fd), 473 ShouldClose(shouldClose), Error(false), UseAtomicWrites(false) { 474#ifdef O_BINARY 475 // Setting STDOUT and STDERR to binary mode is necessary in Win32 476 // to avoid undesirable linefeed conversion. 477 if (fd == STDOUT_FILENO || fd == STDERR_FILENO) 478 setmode(fd, O_BINARY); 479#endif 480 481 // Get the starting position. 482 off_t loc = ::lseek(FD, 0, SEEK_CUR); 483 if (loc == (off_t)-1) 484 pos = 0; 485 else 486 pos = static_cast<uint64_t>(loc); 487} 488 489raw_fd_ostream::~raw_fd_ostream() { 490 if (FD >= 0) { 491 flush(); 492 if (ShouldClose) 493 while (::close(FD) != 0) 494 if (errno != EINTR) { 495 error_detected(); 496 break; 497 } 498 } 499 500#ifdef __MINGW32__ 501 // On mingw, global dtors should not call exit(). 502 // report_fatal_error() invokes exit(). We know report_fatal_error() 503 // might not write messages to stderr when any errors were detected 504 // on FD == 2. 505 if (FD == 2) return; 506#endif 507 508 // If there are any pending errors, report them now. Clients wishing 509 // to avoid report_fatal_error calls should check for errors with 510 // has_error() and clear the error flag with clear_error() before 511 // destructing raw_ostream objects which may have errors. 512 if (has_error()) 513 report_fatal_error("IO failure on output stream."); 514} 515 516 517void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { 518 assert(FD >= 0 && "File already closed."); 519 pos += Size; 520 521 do { 522 ssize_t ret; 523 524 // Check whether we should attempt to use atomic writes. 525 if (BUILTIN_EXPECT(!UseAtomicWrites, true)) { 526 ret = ::write(FD, Ptr, Size); 527 } else { 528 // Use ::writev() where available. 529#if defined(HAVE_WRITEV) 530 struct iovec IOV = { (void*) Ptr, Size }; 531 ret = ::writev(FD, &IOV, 1); 532#else 533 ret = ::write(FD, Ptr, Size); 534#endif 535 } 536 537 if (ret < 0) { 538 // If it's a recoverable error, swallow it and retry the write. 539 // 540 // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since 541 // raw_ostream isn't designed to do non-blocking I/O. However, some 542 // programs, such as old versions of bjam, have mistakenly used 543 // O_NONBLOCK. For compatibility, emulate blocking semantics by 544 // spinning until the write succeeds. If you don't want spinning, 545 // don't use O_NONBLOCK file descriptors with raw_ostream. 546 if (errno == EINTR || errno == EAGAIN 547#ifdef EWOULDBLOCK 548 || errno == EWOULDBLOCK 549#endif 550 ) 551 continue; 552 553 // Otherwise it's a non-recoverable error. Note it and quit. 554 error_detected(); 555 break; 556 } 557 558 // The write may have written some or all of the data. Update the 559 // size and buffer pointer to reflect the remainder that needs 560 // to be written. If there are no bytes left, we're done. 561 Ptr += ret; 562 Size -= ret; 563 } while (Size > 0); 564} 565 566void raw_fd_ostream::close() { 567 assert(ShouldClose); 568 ShouldClose = false; 569 flush(); 570 while (::close(FD) != 0) 571 if (errno != EINTR) { 572 error_detected(); 573 break; 574 } 575 FD = -1; 576} 577 578uint64_t raw_fd_ostream::seek(uint64_t off) { 579 flush(); 580 pos = ::lseek(FD, off, SEEK_SET); 581 if (pos != off) 582 error_detected(); 583 return pos; 584} 585 586size_t raw_fd_ostream::preferred_buffer_size() const { 587#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix) 588 // Windows and Minix have no st_blksize. 589 assert(FD >= 0 && "File not yet open!"); 590 struct stat statbuf; 591 if (fstat(FD, &statbuf) != 0) 592 return 0; 593 594 // If this is a terminal, don't use buffering. Line buffering 595 // would be a more traditional thing to do, but it's not worth 596 // the complexity. 597 if (S_ISCHR(statbuf.st_mode) && isatty(FD)) 598 return 0; 599 // Return the preferred block size. 600 return statbuf.st_blksize; 601#else 602 return raw_ostream::preferred_buffer_size(); 603#endif 604} 605 606raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold, 607 bool bg) { 608 if (sys::Process::ColorNeedsFlush()) 609 flush(); 610 const char *colorcode = 611 (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg) 612 : sys::Process::OutputColor(colors, bold, bg); 613 if (colorcode) { 614 size_t len = strlen(colorcode); 615 write(colorcode, len); 616 // don't account colors towards output characters 617 pos -= len; 618 } 619 return *this; 620} 621 622raw_ostream &raw_fd_ostream::resetColor() { 623 if (sys::Process::ColorNeedsFlush()) 624 flush(); 625 const char *colorcode = sys::Process::ResetColor(); 626 if (colorcode) { 627 size_t len = strlen(colorcode); 628 write(colorcode, len); 629 // don't account colors towards output characters 630 pos -= len; 631 } 632 return *this; 633} 634 635bool raw_fd_ostream::is_displayed() const { 636 return sys::Process::FileDescriptorIsDisplayed(FD); 637} 638 639//===----------------------------------------------------------------------===// 640// outs(), errs(), nulls() 641//===----------------------------------------------------------------------===// 642 643/// outs() - This returns a reference to a raw_ostream for standard output. 644/// Use it like: outs() << "foo" << "bar"; 645raw_ostream &llvm::outs() { 646 // Set buffer settings to model stdout behavior. 647 // Delete the file descriptor when the program exists, forcing error 648 // detection. If you don't want this behavior, don't use outs(). 649 static raw_fd_ostream S(STDOUT_FILENO, true); 650 return S; 651} 652 653/// errs() - This returns a reference to a raw_ostream for standard error. 654/// Use it like: errs() << "foo" << "bar"; 655raw_ostream &llvm::errs() { 656 // Set standard error to be unbuffered by default. 657 static raw_fd_ostream S(STDERR_FILENO, false, true); 658 return S; 659} 660 661/// nulls() - This returns a reference to a raw_ostream which discards output. 662raw_ostream &llvm::nulls() { 663 static raw_null_ostream S; 664 return S; 665} 666 667 668//===----------------------------------------------------------------------===// 669// raw_string_ostream 670//===----------------------------------------------------------------------===// 671 672raw_string_ostream::~raw_string_ostream() { 673 flush(); 674} 675 676void raw_string_ostream::write_impl(const char *Ptr, size_t Size) { 677 OS.append(Ptr, Size); 678} 679 680//===----------------------------------------------------------------------===// 681// raw_svector_ostream 682//===----------------------------------------------------------------------===// 683 684// The raw_svector_ostream implementation uses the SmallVector itself as the 685// buffer for the raw_ostream. We guarantee that the raw_ostream buffer is 686// always pointing past the end of the vector, but within the vector 687// capacity. This allows raw_ostream to write directly into the correct place, 688// and we only need to set the vector size when the data is flushed. 689 690raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) { 691 // Set up the initial external buffer. We make sure that the buffer has at 692 // least 128 bytes free; raw_ostream itself only requires 64, but we want to 693 // make sure that we don't grow the buffer unnecessarily on destruction (when 694 // the data is flushed). See the FIXME below. 695 OS.reserve(OS.size() + 128); 696 SetBuffer(OS.end(), OS.capacity() - OS.size()); 697} 698 699raw_svector_ostream::~raw_svector_ostream() { 700 // FIXME: Prevent resizing during this flush(). 701 flush(); 702} 703 704/// resync - This is called when the SmallVector we're appending to is changed 705/// outside of the raw_svector_ostream's control. It is only safe to do this 706/// if the raw_svector_ostream has previously been flushed. 707void raw_svector_ostream::resync() { 708 assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector"); 709 710 if (OS.capacity() - OS.size() < 64) 711 OS.reserve(OS.capacity() * 2); 712 SetBuffer(OS.end(), OS.capacity() - OS.size()); 713} 714 715void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { 716 // If we're writing bytes from the end of the buffer into the smallvector, we 717 // don't need to copy the bytes, just commit the bytes because they are 718 // already in the right place. 719 if (Ptr == OS.end()) { 720 assert(OS.size() + Size <= OS.capacity() && "Invalid write_impl() call!"); 721 OS.set_size(OS.size() + Size); 722 } else { 723 assert(GetNumBytesInBuffer() == 0 && 724 "Should be writing from buffer if some bytes in it"); 725 // Otherwise, do copy the bytes. 726 OS.append(Ptr, Ptr+Size); 727 } 728 729 // Grow the vector if necessary. 730 if (OS.capacity() - OS.size() < 64) 731 OS.reserve(OS.capacity() * 2); 732 733 // Update the buffer position. 734 SetBuffer(OS.end(), OS.capacity() - OS.size()); 735} 736 737uint64_t raw_svector_ostream::current_pos() const { 738 return OS.size(); 739} 740 741StringRef raw_svector_ostream::str() { 742 flush(); 743 return StringRef(OS.begin(), OS.size()); 744} 745 746//===----------------------------------------------------------------------===// 747// raw_null_ostream 748//===----------------------------------------------------------------------===// 749 750raw_null_ostream::~raw_null_ostream() { 751#ifndef NDEBUG 752 // ~raw_ostream asserts that the buffer is empty. This isn't necessary 753 // with raw_null_ostream, but it's better to have raw_null_ostream follow 754 // the rules than to change the rules just for raw_null_ostream. 755 flush(); 756#endif 757} 758 759void raw_null_ostream::write_impl(const char *Ptr, size_t Size) { 760} 761 762uint64_t raw_null_ostream::current_pos() const { 763 return 0; 764} 765