LLVM  3.7.0
raw_ostream.cpp
Go to the documentation of this file.
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 
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"
22 #include "llvm/Support/Format.h"
24 #include "llvm/Support/Process.h"
25 #include "llvm/Support/Program.h"
26 #include <cctype>
27 #include <cerrno>
28 #include <sys/stat.h>
29 #include <system_error>
30 
31 // <fcntl.h> may provide O_BINARY.
32 #if defined(HAVE_FCNTL_H)
33 # include <fcntl.h>
34 #endif
35 
36 #if defined(HAVE_UNISTD_H)
37 # include <unistd.h>
38 #endif
39 #if defined(HAVE_SYS_UIO_H) && defined(HAVE_WRITEV)
40 # include <sys/uio.h>
41 #endif
42 
43 #if defined(__CYGWIN__)
44 #include <io.h>
45 #endif
46 
47 #if defined(_MSC_VER)
48 #include <io.h>
49 #ifndef STDIN_FILENO
50 # define STDIN_FILENO 0
51 #endif
52 #ifndef STDOUT_FILENO
53 # define STDOUT_FILENO 1
54 #endif
55 #ifndef STDERR_FILENO
56 # define STDERR_FILENO 2
57 #endif
58 #endif
59 
60 using namespace llvm;
61 
63  // raw_ostream's subclasses should take care to flush the buffer
64  // in their destructors.
65  assert(OutBufCur == OutBufStart &&
66  "raw_ostream destructor called with non-empty buffer!");
67 
68  if (BufferMode == InternalBuffer)
69  delete [] OutBufStart;
70 }
71 
72 // An out of line virtual method to provide a home for the class vtable.
73 void raw_ostream::handle() {}
74 
76  // BUFSIZ is intended to be a reasonable default.
77  return BUFSIZ;
78 }
79 
81  // Ask the subclass to determine an appropriate buffer size.
82  if (size_t Size = preferred_buffer_size())
83  SetBufferSize(Size);
84  else
85  // It may return 0, meaning this stream should be unbuffered.
86  SetUnbuffered();
87 }
88 
89 void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
90  BufferKind Mode) {
91  assert(((Mode == Unbuffered && !BufferStart && Size == 0) ||
92  (Mode != Unbuffered && BufferStart && Size != 0)) &&
93  "stream must be unbuffered or have at least one byte");
94  // Make sure the current buffer is free of content (we can't flush here; the
95  // child buffer management logic will be in write_impl).
96  assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
97 
98  if (BufferMode == InternalBuffer)
99  delete [] OutBufStart;
100  OutBufStart = BufferStart;
101  OutBufEnd = OutBufStart+Size;
102  OutBufCur = OutBufStart;
103  BufferMode = Mode;
104 
105  assert(OutBufStart <= OutBufEnd && "Invalid size!");
106 }
107 
109  // Zero is a special case.
110  if (N == 0)
111  return *this << '0';
112 
113  char NumberBuffer[20];
114  char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
115  char *CurPtr = EndPtr;
116 
117  while (N) {
118  *--CurPtr = '0' + char(N % 10);
119  N /= 10;
120  }
121  return write(CurPtr, EndPtr-CurPtr);
122 }
123 
125  if (N < 0) {
126  *this << '-';
127  // Avoid undefined behavior on LONG_MIN with a cast.
128  N = -(unsigned long)N;
129  }
130 
131  return this->operator<<(static_cast<unsigned long>(N));
132 }
133 
134 raw_ostream &raw_ostream::operator<<(unsigned long long N) {
135  // Output using 32-bit div/mod when possible.
136  if (N == static_cast<unsigned long>(N))
137  return this->operator<<(static_cast<unsigned long>(N));
138 
139  char NumberBuffer[20];
140  char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
141  char *CurPtr = EndPtr;
142 
143  while (N) {
144  *--CurPtr = '0' + char(N % 10);
145  N /= 10;
146  }
147  return write(CurPtr, EndPtr-CurPtr);
148 }
149 
151  if (N < 0) {
152  *this << '-';
153  // Avoid undefined behavior on INT64_MIN with a cast.
154  N = -(unsigned long long)N;
155  }
156 
157  return this->operator<<(static_cast<unsigned long long>(N));
158 }
159 
160 raw_ostream &raw_ostream::write_hex(unsigned long long N) {
161  // Zero is a special case.
162  if (N == 0)
163  return *this << '0';
164 
165  char NumberBuffer[20];
166  char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
167  char *CurPtr = EndPtr;
168 
169  while (N) {
170  uintptr_t x = N % 16;
171  *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10);
172  N /= 16;
173  }
174 
175  return write(CurPtr, EndPtr-CurPtr);
176 }
177 
179  bool UseHexEscapes) {
180  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
181  unsigned char c = Str[i];
182 
183  switch (c) {
184  case '\\':
185  *this << '\\' << '\\';
186  break;
187  case '\t':
188  *this << '\\' << 't';
189  break;
190  case '\n':
191  *this << '\\' << 'n';
192  break;
193  case '"':
194  *this << '\\' << '"';
195  break;
196  default:
197  if (std::isprint(c)) {
198  *this << c;
199  break;
200  }
201 
202  // Write out the escaped representation.
203  if (UseHexEscapes) {
204  *this << '\\' << 'x';
205  *this << hexdigit((c >> 4 & 0xF));
206  *this << hexdigit((c >> 0) & 0xF);
207  } else {
208  // Always use a full 3-character octal escape.
209  *this << '\\';
210  *this << char('0' + ((c >> 6) & 7));
211  *this << char('0' + ((c >> 3) & 7));
212  *this << char('0' + ((c >> 0) & 7));
213  }
214  }
215  }
216 
217  return *this;
218 }
219 
221  *this << '0' << 'x';
222 
223  return write_hex((uintptr_t) P);
224 }
225 
227 #ifdef _WIN32
228  // On MSVCRT and compatible, output of %e is incompatible to Posix
229  // by default. Number of exponent digits should be at least 2. "%+03d"
230  // FIXME: Implement our formatter to here or Support/Format.h!
231 #if __cplusplus >= 201103L && defined(__MINGW32__)
232  // FIXME: It should be generic to C++11.
233  if (N == 0.0 && std::signbit(N))
234  return *this << "-0.000000e+00";
235 #else
236  int fpcl = _fpclass(N);
237 
238  // negative zero
239  if (fpcl == _FPCLASS_NZ)
240  return *this << "-0.000000e+00";
241 #endif
242 
243  char buf[16];
244  unsigned len;
245  len = format("%e", N).snprint(buf, sizeof(buf));
246  if (len <= sizeof(buf) - 2) {
247  if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') {
248  int cs = buf[len - 4];
249  if (cs == '+' || cs == '-') {
250  int c1 = buf[len - 2];
251  int c0 = buf[len - 1];
252  if (isdigit(static_cast<unsigned char>(c1)) &&
253  isdigit(static_cast<unsigned char>(c0))) {
254  // Trim leading '0': "...e+012" -> "...e+12\0"
255  buf[len - 3] = c1;
256  buf[len - 2] = c0;
257  buf[--len] = 0;
258  }
259  }
260  }
261  return this->operator<<(buf);
262  }
263 #endif
264  return this->operator<<(format("%e", N));
265 }
266 
267 
268 
269 void raw_ostream::flush_nonempty() {
270  assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
271  size_t Length = OutBufCur - OutBufStart;
272  OutBufCur = OutBufStart;
273  write_impl(OutBufStart, Length);
274 }
275 
276 raw_ostream &raw_ostream::write(unsigned char C) {
277  // Group exceptional cases into a single branch.
278  if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) {
279  if (LLVM_UNLIKELY(!OutBufStart)) {
280  if (BufferMode == Unbuffered) {
281  write_impl(reinterpret_cast<char*>(&C), 1);
282  return *this;
283  }
284  // Set up a buffer and start over.
285  SetBuffered();
286  return write(C);
287  }
288 
289  flush_nonempty();
290  }
291 
292  *OutBufCur++ = C;
293  return *this;
294 }
295 
296 raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
297  // Group exceptional cases into a single branch.
298  if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) {
299  if (LLVM_UNLIKELY(!OutBufStart)) {
300  if (BufferMode == Unbuffered) {
301  write_impl(Ptr, Size);
302  return *this;
303  }
304  // Set up a buffer and start over.
305  SetBuffered();
306  return write(Ptr, Size);
307  }
308 
309  size_t NumBytes = OutBufEnd - OutBufCur;
310 
311  // If the buffer is empty at this point we have a string that is larger
312  // than the buffer. Directly write the chunk that is a multiple of the
313  // preferred buffer size and put the remainder in the buffer.
314  if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) {
315  assert(NumBytes != 0 && "undefined behavior");
316  size_t BytesToWrite = Size - (Size % NumBytes);
317  write_impl(Ptr, BytesToWrite);
318  size_t BytesRemaining = Size - BytesToWrite;
319  if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) {
320  // Too much left over to copy into our buffer.
321  return write(Ptr + BytesToWrite, BytesRemaining);
322  }
323  copy_to_buffer(Ptr + BytesToWrite, BytesRemaining);
324  return *this;
325  }
326 
327  // We don't have enough space in the buffer to fit the string in. Insert as
328  // much as possible, flush and start over with the remainder.
329  copy_to_buffer(Ptr, NumBytes);
330  flush_nonempty();
331  return write(Ptr + NumBytes, Size - NumBytes);
332  }
333 
334  copy_to_buffer(Ptr, Size);
335 
336  return *this;
337 }
338 
339 void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
340  assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
341 
342  // Handle short strings specially, memcpy isn't very good at very short
343  // strings.
344  switch (Size) {
345  case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH
346  case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH
347  case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH
348  case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH
349  case 0: break;
350  default:
351  memcpy(OutBufCur, Ptr, Size);
352  break;
353  }
354 
355  OutBufCur += Size;
356 }
357 
358 // Formatted output.
360  // If we have more than a few bytes left in our output buffer, try
361  // formatting directly onto its end.
362  size_t NextBufferSize = 127;
363  size_t BufferBytesLeft = OutBufEnd - OutBufCur;
364  if (BufferBytesLeft > 3) {
365  size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
366 
367  // Common case is that we have plenty of space.
368  if (BytesUsed <= BufferBytesLeft) {
369  OutBufCur += BytesUsed;
370  return *this;
371  }
372 
373  // Otherwise, we overflowed and the return value tells us the size to try
374  // again with.
375  NextBufferSize = BytesUsed;
376  }
377 
378  // If we got here, we didn't have enough space in the output buffer for the
379  // string. Try printing into a SmallVector that is resized to have enough
380  // space. Iterate until we win.
382 
383  while (1) {
384  V.resize(NextBufferSize);
385 
386  // Try formatting into the SmallVector.
387  size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
388 
389  // If BytesUsed fit into the vector, we win.
390  if (BytesUsed <= NextBufferSize)
391  return write(V.data(), BytesUsed);
392 
393  // Otherwise, try again with a new size.
394  assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
395  NextBufferSize = BytesUsed;
396  }
397 }
398 
400  unsigned Len = FS.Str.size();
401  int PadAmount = FS.Width - Len;
402  if (FS.RightJustify && (PadAmount > 0))
403  this->indent(PadAmount);
404  this->operator<<(FS.Str);
405  if (!FS.RightJustify && (PadAmount > 0))
406  this->indent(PadAmount);
407  return *this;
408 }
409 
411  if (FN.Hex) {
412  unsigned Nibbles = (64 - countLeadingZeros(FN.HexValue)+3)/4;
413  unsigned PrefixChars = FN.HexPrefix ? 2 : 0;
414  unsigned Width = std::max(FN.Width, Nibbles + PrefixChars);
415 
416  char NumberBuffer[20] = "0x0000000000000000";
417  if (!FN.HexPrefix)
418  NumberBuffer[1] = '0';
419  char *EndPtr = NumberBuffer+Width;
420  char *CurPtr = EndPtr;
421  const char A = FN.Upper ? 'A' : 'a';
422  unsigned long long N = FN.HexValue;
423  while (N) {
424  uintptr_t x = N % 16;
425  *--CurPtr = (x < 10 ? '0' + x : A + x - 10);
426  N /= 16;
427  }
428 
429  return write(NumberBuffer, Width);
430  } else {
431  // Zero is a special case.
432  if (FN.DecValue == 0) {
433  this->indent(FN.Width-1);
434  return *this << '0';
435  }
436  char NumberBuffer[32];
437  char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
438  char *CurPtr = EndPtr;
439  bool Neg = (FN.DecValue < 0);
440  uint64_t N = Neg ? -static_cast<uint64_t>(FN.DecValue) : FN.DecValue;
441  while (N) {
442  *--CurPtr = '0' + char(N % 10);
443  N /= 10;
444  }
445  int Len = EndPtr - CurPtr;
446  int Pad = FN.Width - Len;
447  if (Neg)
448  --Pad;
449  if (Pad > 0)
450  this->indent(Pad);
451  if (Neg)
452  *this << '-';
453  return write(CurPtr, Len);
454  }
455 }
456 
457 
458 /// indent - Insert 'NumSpaces' spaces.
459 raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
460  static const char Spaces[] = " "
461  " "
462  " ";
463 
464  // Usually the indentation is small, handle it with a fastpath.
465  if (NumSpaces < array_lengthof(Spaces))
466  return write(Spaces, NumSpaces);
467 
468  while (NumSpaces) {
469  unsigned NumToWrite = std::min(NumSpaces,
470  (unsigned)array_lengthof(Spaces)-1);
471  write(Spaces, NumToWrite);
472  NumSpaces -= NumToWrite;
473  }
474  return *this;
475 }
476 
477 
478 //===----------------------------------------------------------------------===//
479 // Formatted Output
480 //===----------------------------------------------------------------------===//
481 
482 // Out of line virtual method.
484 }
485 
486 //===----------------------------------------------------------------------===//
487 // raw_fd_ostream
488 //===----------------------------------------------------------------------===//
489 
490 static int getFD(StringRef Filename, std::error_code &EC,
492  // Handle "-" as stdout. Note that when we do this, we consider ourself
493  // the owner of stdout. This means that we can do things like close the
494  // file descriptor when we're done and set the "binary" flag globally.
495  if (Filename == "-") {
496  EC = std::error_code();
497  // If user requested binary then put stdout into binary mode if
498  // possible.
499  if (!(Flags & sys::fs::F_Text))
501  return STDOUT_FILENO;
502  }
503 
504  int FD;
505  EC = sys::fs::openFileForWrite(Filename, FD, Flags);
506  if (EC)
507  return -1;
508 
509  return FD;
510 }
511 
512 raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
514  : raw_fd_ostream(getFD(Filename, EC, Flags), true) {}
515 
516 /// FD is the file descriptor that this writes to. If ShouldClose is true, this
517 /// closes the file when the stream is destroyed.
518 raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
519  : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose),
520  Error(false), UseAtomicWrites(false) {
521  if (FD < 0 ) {
522  ShouldClose = false;
523  return;
524  }
525 
526  // Get the starting position.
527  off_t loc = ::lseek(FD, 0, SEEK_CUR);
528 #ifdef LLVM_ON_WIN32
529  // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
531  std::error_code EC = status(FD, Status);
532  SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file;
533 #else
534  SupportsSeeking = loc != (off_t)-1;
535 #endif
536  if (!SupportsSeeking)
537  pos = 0;
538  else
539  pos = static_cast<uint64_t>(loc);
540 }
541 
543  if (FD >= 0) {
544  flush();
545  if (ShouldClose && sys::Process::SafelyCloseFileDescriptor(FD))
546  error_detected();
547  }
548 
549 #ifdef __MINGW32__
550  // On mingw, global dtors should not call exit().
551  // report_fatal_error() invokes exit(). We know report_fatal_error()
552  // might not write messages to stderr when any errors were detected
553  // on FD == 2.
554  if (FD == 2) return;
555 #endif
556 
557  // If there are any pending errors, report them now. Clients wishing
558  // to avoid report_fatal_error calls should check for errors with
559  // has_error() and clear the error flag with clear_error() before
560  // destructing raw_ostream objects which may have errors.
561  if (has_error())
562  report_fatal_error("IO failure on output stream.", /*GenCrashDiag=*/false);
563 }
564 
565 
566 void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
567  assert(FD >= 0 && "File already closed.");
568  pos += Size;
569 
570  do {
571  ssize_t ret;
572 
573  // Check whether we should attempt to use atomic writes.
574  if (LLVM_LIKELY(!UseAtomicWrites)) {
575  ret = ::write(FD, Ptr, Size);
576  } else {
577  // Use ::writev() where available.
578 #if defined(HAVE_WRITEV)
579  const void *Addr = static_cast<const void *>(Ptr);
580  struct iovec IOV = {const_cast<void *>(Addr), Size };
581  ret = ::writev(FD, &IOV, 1);
582 #else
583  ret = ::write(FD, Ptr, Size);
584 #endif
585  }
586 
587  if (ret < 0) {
588  // If it's a recoverable error, swallow it and retry the write.
589  //
590  // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since
591  // raw_ostream isn't designed to do non-blocking I/O. However, some
592  // programs, such as old versions of bjam, have mistakenly used
593  // O_NONBLOCK. For compatibility, emulate blocking semantics by
594  // spinning until the write succeeds. If you don't want spinning,
595  // don't use O_NONBLOCK file descriptors with raw_ostream.
596  if (errno == EINTR || errno == EAGAIN
597 #ifdef EWOULDBLOCK
598  || errno == EWOULDBLOCK
599 #endif
600  )
601  continue;
602 
603  // Otherwise it's a non-recoverable error. Note it and quit.
604  error_detected();
605  break;
606  }
607 
608  // The write may have written some or all of the data. Update the
609  // size and buffer pointer to reflect the remainder that needs
610  // to be written. If there are no bytes left, we're done.
611  Ptr += ret;
612  Size -= ret;
613  } while (Size > 0);
614 }
615 
617  assert(ShouldClose);
618  ShouldClose = false;
619  flush();
621  error_detected();
622  FD = -1;
623 }
624 
625 uint64_t raw_fd_ostream::seek(uint64_t off) {
626  flush();
627  pos = ::lseek(FD, off, SEEK_SET);
628  if (pos == (uint64_t)-1)
629  error_detected();
630  return pos;
631 }
632 
633 void raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size,
634  uint64_t Offset) {
635  uint64_t Pos = tell();
636  seek(Offset);
637  write(Ptr, Size);
638  seek(Pos);
639 }
640 
641 size_t raw_fd_ostream::preferred_buffer_size() const {
642 #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix)
643  // Windows and Minix have no st_blksize.
644  assert(FD >= 0 && "File not yet open!");
645  struct stat statbuf;
646  if (fstat(FD, &statbuf) != 0)
647  return 0;
648 
649  // If this is a terminal, don't use buffering. Line buffering
650  // would be a more traditional thing to do, but it's not worth
651  // the complexity.
652  if (S_ISCHR(statbuf.st_mode) && isatty(FD))
653  return 0;
654  // Return the preferred block size.
655  return statbuf.st_blksize;
656 #else
658 #endif
659 }
660 
662  bool bg) {
664  flush();
665  const char *colorcode =
666  (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
667  : sys::Process::OutputColor(colors, bold, bg);
668  if (colorcode) {
669  size_t len = strlen(colorcode);
670  write(colorcode, len);
671  // don't account colors towards output characters
672  pos -= len;
673  }
674  return *this;
675 }
676 
679  flush();
680  const char *colorcode = sys::Process::ResetColor();
681  if (colorcode) {
682  size_t len = strlen(colorcode);
683  write(colorcode, len);
684  // don't account colors towards output characters
685  pos -= len;
686  }
687  return *this;
688 }
689 
692  flush();
693  const char *colorcode = sys::Process::OutputReverse();
694  if (colorcode) {
695  size_t len = strlen(colorcode);
696  write(colorcode, len);
697  // don't account colors towards output characters
698  pos -= len;
699  }
700  return *this;
701 }
702 
705 }
706 
709 }
710 
711 //===----------------------------------------------------------------------===//
712 // outs(), errs(), nulls()
713 //===----------------------------------------------------------------------===//
714 
715 /// outs() - This returns a reference to a raw_ostream for standard output.
716 /// Use it like: outs() << "foo" << "bar";
718  // Set buffer settings to model stdout behavior.
719  // Delete the file descriptor when the program exits, forcing error
720  // detection. If you don't want this behavior, don't use outs().
721  std::error_code EC;
722  static raw_fd_ostream S("-", EC, sys::fs::F_None);
723  assert(!EC);
724  return S;
725 }
726 
727 /// errs() - This returns a reference to a raw_ostream for standard error.
728 /// Use it like: errs() << "foo" << "bar";
730  // Set standard error to be unbuffered by default.
731  static raw_fd_ostream S(STDERR_FILENO, false, true);
732  return S;
733 }
734 
735 /// nulls() - This returns a reference to a raw_ostream which discards output.
737  static raw_null_ostream S;
738  return S;
739 }
740 
741 
742 //===----------------------------------------------------------------------===//
743 // raw_string_ostream
744 //===----------------------------------------------------------------------===//
745 
747  flush();
748 }
749 
750 void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
751  OS.append(Ptr, Size);
752 }
753 
754 //===----------------------------------------------------------------------===//
755 // raw_svector_ostream
756 //===----------------------------------------------------------------------===//
757 
758 // The raw_svector_ostream implementation uses the SmallVector itself as the
759 // buffer for the raw_ostream. We guarantee that the raw_ostream buffer is
760 // always pointing past the end of the vector, but within the vector
761 // capacity. This allows raw_ostream to write directly into the correct place,
762 // and we only need to set the vector size when the data is flushed.
763 
765  : OS(O) {}
766 
768  init();
769 }
770 
772  // Set up the initial external buffer. We make sure that the buffer has at
773  // least 128 bytes free; raw_ostream itself only requires 64, but we want to
774  // make sure that we don't grow the buffer unnecessarily on destruction (when
775  // the data is flushed). See the FIXME below.
776  OS.reserve(OS.size() + 128);
777  SetBuffer(OS.end(), OS.capacity() - OS.size());
778 }
779 
781  // FIXME: Prevent resizing during this flush().
782  flush();
783 }
784 
785 void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
786  uint64_t Offset) {
787  flush();
788  memcpy(OS.begin() + Offset, Ptr, Size);
789 }
790 
791 /// resync - This is called when the SmallVector we're appending to is changed
792 /// outside of the raw_svector_ostream's control. It is only safe to do this
793 /// if the raw_svector_ostream has previously been flushed.
795  assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector");
796 
797  if (OS.capacity() - OS.size() < 64)
798  OS.reserve(OS.capacity() * 2);
799  SetBuffer(OS.end(), OS.capacity() - OS.size());
800 }
801 
802 void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
803  if (Ptr == OS.end()) {
804  // Grow the buffer to include the scratch area without copying.
805  size_t NewSize = OS.size() + Size;
806  assert(NewSize <= OS.capacity() && "Invalid write_impl() call!");
807  OS.set_size(NewSize);
808  } else {
809  assert(!GetNumBytesInBuffer());
810  OS.append(Ptr, Ptr + Size);
811  }
812 
813  OS.reserve(OS.size() + 64);
814  SetBuffer(OS.end(), OS.capacity() - OS.size());
815 }
816 
817 uint64_t raw_svector_ostream::current_pos() const {
818  return OS.size();
819 }
820 
822  flush();
823  return StringRef(OS.begin(), OS.size());
824 }
825 
826 //===----------------------------------------------------------------------===//
827 // raw_null_ostream
828 //===----------------------------------------------------------------------===//
829 
831 #ifndef NDEBUG
832  // ~raw_ostream asserts that the buffer is empty. This isn't necessary
833  // with raw_null_ostream, but it's better to have raw_null_ostream follow
834  // the rules than to change the rules just for raw_null_ostream.
835  flush();
836 #endif
837 }
838 
839 void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
840 }
841 
842 uint64_t raw_null_ostream::current_pos() const {
843  return 0;
844 }
845 
846 void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
847  uint64_t Offset) {}
bool has_colors() const override
This function determines if this stream is displayed and supports colors.
bool is_displayed() const override
This function determines if this stream is connected to a "tty" or "console" window.
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
size_t capacity() const
Return the total number of elements in the currently allocated buffer.
Definition: SmallVector.h:131
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
static const char * ResetColor()
Resets the terminals colors, or returns an escape sequence to do so.
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:174
#define LLVM_LIKELY(EXPR)
Definition: Compiler.h:173
static const char * OutputColor(char c, bool bold, bool bg)
This function returns the colorcode escape sequences.
std::error_code ChangeStdoutToBinary()
A raw_ostream that discards all output.
Definition: raw_ostream.h:525
virtual ~raw_ostream()
Definition: raw_ostream.cpp:62
uint64_t seek(uint64_t off)
Flushes the stream and repositions the underlying file descriptor position to the offset specified fr...
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
static bool FileDescriptorHasColors(int fd)
This function determines if the given file descriptor is displayd and supports colors.
raw_svector_ostream(SmallVectorImpl< char > &O, unsigned)
static bool FileDescriptorIsDisplayed(int fd)
This function determines if the given file descriptor is connected to a "tty" or "console" window...
void reserve(size_type N)
Definition: SmallVector.h:401
file_status - Represents the result of a call to stat and friends.
Definition: FileSystem.h:138
std::size_t countLeadingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0's from the most significant bit to the least stopping at the first 1...
Definition: MathExtras.h:178
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
This is a helper class used for left_justify() and right_justify().
Definition: Format.h:116
static bool ColorNeedsFlush()
Whether changing colors requires the output to be flushed.
bool has_error() const
Return the value of the flag in this raw_fd_ostream indicating whether an output error has been encou...
Definition: raw_ostream.h:430
static const char * OutputReverse()
This function returns the escape sequence to reverse forground and background colors.
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
void SetBuffer(char *BufferStart, size_t Size)
Use the provided buffer as the raw_ostream buffer.
Definition: raw_ostream.h:291
#define false
Definition: ConvertUTF.c:65
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:92
raw_ostream & write_hex(unsigned long long N)
Output N in hexadecimal, without any prefix or padding.
~raw_fd_ostream() override
This is a helper class used for handling formatted output.
Definition: Format.h:37
raw_ostream & operator<<(char C)
Definition: raw_ostream.h:139
format_object< Ts...> format(const char *Fmt, const Ts &...Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:111
LLVM_CONSTEXPR size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:247
unsigned print(char *Buffer, unsigned BufferSize) const
Format the object into the specified buffer.
Definition: Format.h:53
raw_ostream & outs()
This returns a reference to a raw_ostream for standard output.
#define P(N)
static int getFD(StringRef Filename, std::error_code &EC, sys::fs::OpenFlags Flags)
#define true
Definition: ConvertUTF.c:66
raw_ostream & resetColor() override
Resets the colors to terminal defaults.
void resync()
This is called when the SmallVector we're appending to is changed outside of the raw_svector_ostream'...
void SetUnbuffered()
Set the stream to be unbuffered.
Definition: raw_ostream.h:121
raw_fd_ostream(StringRef Filename, std::error_code &EC, sys::fs::OpenFlags Flags)
Open the specified file for writing.
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:416
void SetBufferSize(size_t Size)
Set the stream to be buffered, using the specified buffer size.
Definition: raw_ostream.h:103
~raw_null_ostream() override
raw_ostream & write(unsigned char C)
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '', ' ', '"', and anything that doesn't satisfy std::isprint into an escape...
This is a helper class used for format_hex() and format_decimal().
Definition: Format.h:141
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
virtual size_t preferred_buffer_size() const
Return an efficient buffer size for the underlying output mechanism.
Definition: raw_ostream.cpp:75
The file should be opened in text mode on platforms that make this distinction.
Definition: FileSystem.h:592
void SetBuffered()
Set the stream to be buffered, with an automatically determined buffer size.
Definition: raw_ostream.cpp:80
StringRef str()
Flushes the stream contents to the target vector and return a StringRef for the vector contents...
void set_size(size_type N)
Set the array size to N, which the current array must have enough capacity for.
Definition: SmallVector.h:685
Provides a library for accessing information about this process and other processes on the operating ...
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:345
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:134
#define N
void close()
Manually flush the stream and close the file.
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:321
static const char * OutputBold(bool bg)
Same as OutputColor, but only enables the bold attribute.
raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
raw_ostream & changeColor(enum Colors colors, bool bold=false, bool bg=false) override
Changes the foreground color of text that will be output from this point forward. ...
static std::error_code SafelyCloseFileDescriptor(int FD)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
std::error_code status(const Twine &path, file_status &result)
Get file status as if by POSIX stat().
file_type type() const
Definition: FileSystem.h:196
raw_ostream & reverseColor() override
Reverses the forground and background colors.
size_t GetNumBytesInBuffer() const
Definition: raw_ostream.h:126
void resize(size_type N)
Definition: SmallVector.h:376
std::error_code openFileForWrite(const Twine &Name, int &ResultFD, OpenFlags Flags, unsigned Mode=0666)