blob: 2181ccec0b1a5fba9a43ae5c7d2f1b75490f1828 [file] [log] [blame]
Chris Lattner60d39622008-08-17 01:35:29 +00001//===--- 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"
Chris Lattner42f77ab2008-08-23 20:34:06 +000015#include "llvm/Support/Format.h"
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +000016#include "llvm/System/Program.h"
Torok Edwine8ebb0f2009-06-04 07:09:50 +000017#include "llvm/System/Process.h"
Chris Lattner097af7f2008-08-23 19:23:10 +000018#include "llvm/ADT/SmallVector.h"
Chris Lattner969a46a2008-08-22 15:45:00 +000019#include "llvm/Config/config.h"
Daniel Dunbarb372c112009-03-17 21:15:18 +000020#include "llvm/Support/Compiler.h"
Daniel Dunbar579fb872009-07-15 08:11:46 +000021#include "llvm/Support/ErrorHandling.h"
Chris Lattner07f51f72008-08-17 04:13:37 +000022#include <ostream>
Dan Gohman208ec0f2009-08-13 17:27:29 +000023#include <sys/stat.h>
24#include <sys/types.h>
Chris Lattner60d39622008-08-17 01:35:29 +000025
Chris Lattner969a46a2008-08-22 15:45:00 +000026#if defined(HAVE_UNISTD_H)
27# include <unistd.h>
28#endif
29#if defined(HAVE_FCNTL_H)
30# include <fcntl.h>
31#endif
Argyrios Kyrtzidisb68dc362008-08-17 09:25:21 +000032
33#if defined(_MSC_VER)
Chris Lattner60d39622008-08-17 01:35:29 +000034#include <io.h>
Cedric Veneta3f343f2008-08-24 11:56:40 +000035#include <fcntl.h>
Owen Andersoncb371882008-08-21 00:14:44 +000036#ifndef STDIN_FILENO
37# define STDIN_FILENO 0
38#endif
39#ifndef STDOUT_FILENO
40# define STDOUT_FILENO 1
41#endif
42#ifndef STDERR_FILENO
43# define STDERR_FILENO 2
44#endif
Chris Lattner60d39622008-08-17 01:35:29 +000045#endif
46
Chris Lattner969a46a2008-08-22 15:45:00 +000047using namespace llvm;
48
Dan Gohmane87b2ab2009-07-15 23:25:33 +000049raw_ostream::~raw_ostream() {
Dan Gohman9a312542009-07-27 20:49:44 +000050 // raw_ostream's subclasses should take care to flush the buffer
51 // in their destructors.
52 assert(OutBufCur == OutBufStart &&
53 "raw_ostream destructor called with non-empty buffer!");
54
Daniel Dunbar906d5b42009-08-18 23:42:36 +000055 if (BufferMode == InternalBuffer)
56 delete [] OutBufStart;
Dan Gohmane87b2ab2009-07-15 23:25:33 +000057
58 // If there are any pending errors, report them now. Clients wishing
59 // to avoid llvm_report_error calls should check for errors with
60 // has_error() and clear the error flag with clear_error() before
61 // destructing raw_ostream objects which may have errors.
62 if (Error)
63 llvm_report_error("IO failure on output stream.");
64}
Chris Lattner969a46a2008-08-22 15:45:00 +000065
Chris Lattner60d39622008-08-17 01:35:29 +000066// An out of line virtual method to provide a home for the class vtable.
67void raw_ostream::handle() {}
68
Dan Gohman208ec0f2009-08-13 17:27:29 +000069size_t raw_ostream::preferred_buffer_size() {
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.
Dan Gohmand7be6632009-08-15 02:05:19 +000076 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();
Dan Gohman208ec0f2009-08-13 17:27:29 +000081}
82
Daniel Dunbar906d5b42009-08-18 23:42:36 +000083void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
84 BufferKind Mode) {
85 assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) ||
86 (Mode != Unbuffered && BufferStart && Size >= 64)) &&
87 "stream must be unbuffered, or have >= 64 bytes of buffer");
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!");
Dan Gohman524dea42009-08-13 15:58:55 +000091
Daniel Dunbar906d5b42009-08-18 23:42:36 +000092 if (BufferMode == InternalBuffer)
93 delete [] OutBufStart;
94 OutBufStart = BufferStart;
Dan Gohman524dea42009-08-13 15:58:55 +000095 OutBufEnd = OutBufStart+Size;
96 OutBufCur = OutBufStart;
Daniel Dunbar906d5b42009-08-18 23:42:36 +000097 BufferMode = Mode;
Daniel Dunbar425d08c2009-08-19 17:54:29 +000098
99 assert(OutBufStart <= OutBufEnd && "Invalid size!");
Dan Gohman524dea42009-08-13 15:58:55 +0000100}
101
Owen Anderson66b17ba2008-08-21 20:58:52 +0000102raw_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) {
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000120 *this << '-';
Owen Anderson66b17ba2008-08-21 20:58:52 +0000121 N = -N;
122 }
123
124 return this->operator<<(static_cast<unsigned long>(N));
125}
126
127raw_ostream &raw_ostream::operator<<(unsigned long long N) {
Daniel Dunbarecbd0bc2009-08-19 16:25:25 +0000128 // Output using 32-bit div/mod when possible.
Daniel Dunbar78a3dd82009-07-29 06:45:14 +0000129 if (N == static_cast<unsigned long>(N))
130 return this->operator<<(static_cast<unsigned long>(N));
131
Daniel Dunbarecbd0bc2009-08-19 16:25:25 +0000132 char NumberBuffer[20];
133 char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
134 char *CurPtr = EndPtr;
135
136 while (N) {
137 *--CurPtr = '0' + char(N % 10);
138 N /= 10;
139 }
140 return write(CurPtr, EndPtr-CurPtr);
Owen Anderson66b17ba2008-08-21 20:58:52 +0000141}
142
143raw_ostream &raw_ostream::operator<<(long long N) {
144 if (N < 0) {
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000145 *this << '-';
Owen Anderson66b17ba2008-08-21 20:58:52 +0000146 N = -N;
147 }
148
149 return this->operator<<(static_cast<unsigned long long>(N));
150}
151
Daniel Dunbar48018e02009-07-30 18:21:23 +0000152raw_ostream &raw_ostream::write_hex(unsigned long long N) {
Daniel Dunbarb451a0c2009-03-16 22:08:44 +0000153 // Zero is a special case.
154 if (N == 0)
155 return *this << '0';
156
157 char NumberBuffer[20];
158 char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
159 char *CurPtr = EndPtr;
160
161 while (N) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000162 uintptr_t x = N % 16;
Daniel Dunbarb451a0c2009-03-16 22:08:44 +0000163 *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10);
164 N /= 16;
165 }
166
167 return write(CurPtr, EndPtr-CurPtr);
Chris Lattner944fac72008-08-23 22:23:09 +0000168}
169
Daniel Dunbar48018e02009-07-30 18:21:23 +0000170raw_ostream &raw_ostream::operator<<(const void *P) {
171 *this << '0' << 'x';
172
173 return write_hex((uintptr_t) P);
174}
175
Daniel Dunbarcf2a2c62009-03-16 22:55:06 +0000176void raw_ostream::flush_nonempty() {
177 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000178 size_t Length = OutBufCur - OutBufStart;
179 OutBufCur = OutBufStart;
180 write_impl(OutBufStart, Length);
Daniel Dunbarcf2a2c62009-03-16 22:55:06 +0000181}
182
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000183raw_ostream &raw_ostream::write(unsigned char C) {
Daniel Dunbar262541b2009-03-17 01:36:56 +0000184 // Group exceptional cases into a single branch.
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000185 if (BUILTIN_EXPECT(OutBufCur >= OutBufEnd, false)) {
186 if (BUILTIN_EXPECT(!OutBufStart, false)) {
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000187 if (BufferMode == Unbuffered) {
Dan Gohman37316042009-08-18 20:09:59 +0000188 write_impl(reinterpret_cast<char*>(&C), 1);
189 return *this;
190 }
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000191 // Set up a buffer and start over.
192 SetBuffered();
193 return write(C);
Dan Gohman37316042009-08-18 20:09:59 +0000194 }
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000195
196 flush_nonempty();
Daniel Dunbard17d74b2009-03-17 01:13:35 +0000197 }
198
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000199 *OutBufCur++ = C;
Daniel Dunbarb451a0c2009-03-16 22:08:44 +0000200 return *this;
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000201}
Chris Lattner944fac72008-08-23 22:23:09 +0000202
Dan Gohmanad60f662009-07-16 15:24:40 +0000203raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
Daniel Dunbar262541b2009-03-17 01:36:56 +0000204 // Group exceptional cases into a single branch.
Daniel Dunbarb372c112009-03-17 21:15:18 +0000205 if (BUILTIN_EXPECT(OutBufCur+Size > OutBufEnd, false)) {
Dan Gohman33e49ef2009-08-13 15:44:52 +0000206 if (BUILTIN_EXPECT(!OutBufStart, false)) {
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000207 if (BufferMode == Unbuffered) {
Dan Gohman33e49ef2009-08-13 15:44:52 +0000208 write_impl(Ptr, Size);
209 return *this;
210 }
211 // Set up a buffer and start over.
Dan Gohman208ec0f2009-08-13 17:27:29 +0000212 SetBuffered();
Dan Gohman33e49ef2009-08-13 15:44:52 +0000213 return write(Ptr, Size);
214 }
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000215
Dan Gohman33e49ef2009-08-13 15:44:52 +0000216 // Write out the data in buffer-sized blocks until the remainder
217 // fits within the buffer.
218 do {
219 size_t NumBytes = OutBufEnd - OutBufCur;
220 copy_to_buffer(Ptr, NumBytes);
Daniel Dunbar262541b2009-03-17 01:36:56 +0000221 flush_nonempty();
Dan Gohman33e49ef2009-08-13 15:44:52 +0000222 Ptr += NumBytes;
223 Size -= NumBytes;
224 } while (OutBufCur+Size > OutBufEnd);
Daniel Dunbar262541b2009-03-17 01:36:56 +0000225 }
Dan Gohman33e49ef2009-08-13 15:44:52 +0000226
227 copy_to_buffer(Ptr, Size);
228
229 return *this;
230}
231
232void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
Dan Gohmanc6126e82009-08-13 20:32:03 +0000233 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
Dan Gohman4e8e6422009-08-13 18:38:15 +0000234
Owen Anderson66b17ba2008-08-21 20:58:52 +0000235 // Handle short strings specially, memcpy isn't very good at very short
236 // strings.
237 switch (Size) {
238 case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH
239 case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH
240 case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH
241 case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH
242 case 0: break;
243 default:
Dan Gohman33e49ef2009-08-13 15:44:52 +0000244 memcpy(OutBufCur, Ptr, Size);
Owen Anderson66b17ba2008-08-21 20:58:52 +0000245 break;
246 }
Daniel Dunbare77e4342009-03-10 16:21:55 +0000247
Dan Gohman33e49ef2009-08-13 15:44:52 +0000248 OutBufCur += Size;
Owen Anderson66b17ba2008-08-21 20:58:52 +0000249}
250
Chris Lattner097af7f2008-08-23 19:23:10 +0000251// Formatted output.
252raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
Daniel Dunbar262541b2009-03-17 01:36:56 +0000253 // If we have more than a few bytes left in our output buffer, try
254 // formatting directly onto its end.
Dan Gohmanad60f662009-07-16 15:24:40 +0000255 size_t NextBufferSize = 127;
Chris Lattner097af7f2008-08-23 19:23:10 +0000256 if (OutBufEnd-OutBufCur > 3) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000257 size_t BufferBytesLeft = OutBufEnd-OutBufCur;
258 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
Chris Lattner097af7f2008-08-23 19:23:10 +0000259
260 // Common case is that we have plenty of space.
261 if (BytesUsed < BufferBytesLeft) {
262 OutBufCur += BytesUsed;
263 return *this;
264 }
265
266 // Otherwise, we overflowed and the return value tells us the size to try
267 // again with.
268 NextBufferSize = BytesUsed;
269 }
270
271 // If we got here, we didn't have enough space in the output buffer for the
272 // string. Try printing into a SmallVector that is resized to have enough
273 // space. Iterate until we win.
274 SmallVector<char, 128> V;
275
276 while (1) {
277 V.resize(NextBufferSize);
278
279 // Try formatting into the SmallVector.
Dan Gohmanad60f662009-07-16 15:24:40 +0000280 size_t BytesUsed = Fmt.print(&V[0], NextBufferSize);
Chris Lattner097af7f2008-08-23 19:23:10 +0000281
282 // If BytesUsed fit into the vector, we win.
Chris Lattnerf61ca1e2008-10-26 19:20:47 +0000283 if (BytesUsed <= NextBufferSize)
Chris Lattner097af7f2008-08-23 19:23:10 +0000284 return write(&V[0], BytesUsed);
285
286 // Otherwise, try again with a new size.
287 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
288 NextBufferSize = BytesUsed;
289 }
290}
291
Chris Lattnerc5a227d2009-08-22 23:10:29 +0000292/// indent - Insert 'NumSpaces' spaces.
293raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
294 const char *Spaces = " ";
295
296 // Usually the indentation is small, handle it with a fastpath.
297 if (NumSpaces <= 16)
298 return write(Spaces, NumSpaces);
299
300 while (NumSpaces) {
301 unsigned NumToWrite = std::min(NumSpaces, 16U);
302 write(Spaces, NumToWrite);
303 NumSpaces -= NumToWrite;
304 }
305 return *this;
306}
307
308
Chris Lattner097af7f2008-08-23 19:23:10 +0000309//===----------------------------------------------------------------------===//
310// Formatted Output
311//===----------------------------------------------------------------------===//
312
313// Out of line virtual method.
314void format_object_base::home() {
315}
316
Chris Lattner60d39622008-08-17 01:35:29 +0000317//===----------------------------------------------------------------------===//
318// raw_fd_ostream
319//===----------------------------------------------------------------------===//
320
Daniel Dunbar48534b32008-10-21 19:53:10 +0000321/// raw_fd_ostream - Open the specified file for writing. If an error
322/// occurs, information about the error is put into ErrorInfo, and the
323/// stream should be immediately destroyed; the string will be empty
324/// if no error occurred.
Chris Lattner17e9edc2009-08-23 02:51:22 +0000325raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo,
326 unsigned Flags) : pos(0) {
327 // Verify that we don't have both "append" and "force".
328 assert((!(Flags & F_Force) || !(Flags & F_Append)) &&
329 "Cannot specify both 'force' and 'append' file creation flags!");
330
Daniel Dunbar48534b32008-10-21 19:53:10 +0000331 ErrorInfo.clear();
332
Chris Lattnerc52b1282008-08-17 03:53:23 +0000333 // Handle "-" as stdout.
334 if (Filename[0] == '-' && Filename[1] == 0) {
335 FD = STDOUT_FILENO;
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000336 // If user requested binary then put stdout into binary mode if
337 // possible.
Chris Lattner17e9edc2009-08-23 02:51:22 +0000338 if (Flags & F_Binary)
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000339 sys::Program::ChangeStdoutToBinary();
Chris Lattnerc52b1282008-08-17 03:53:23 +0000340 ShouldClose = false;
341 return;
342 }
343
Chris Lattner17e9edc2009-08-23 02:51:22 +0000344 int OpenFlags = O_WRONLY|O_CREAT;
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000345#ifdef O_BINARY
Benjamin Kramerae603242009-08-23 08:57:52 +0000346 if (Flags & F_Binary)
Chris Lattner17e9edc2009-08-23 02:51:22 +0000347 OpenFlags |= O_BINARY;
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000348#endif
Chris Lattner17e9edc2009-08-23 02:51:22 +0000349
350 if (Flags & F_Force)
351 OpenFlags |= O_TRUNC;
352 else if (Flags & F_Append)
353 OpenFlags |= O_APPEND;
354 else
355 OpenFlags |= O_EXCL;
356
357 FD = open(Filename, OpenFlags, 0664);
Chris Lattner60d39622008-08-17 01:35:29 +0000358 if (FD < 0) {
359 ErrorInfo = "Error opening output file '" + std::string(Filename) + "'";
360 ShouldClose = false;
361 } else {
362 ShouldClose = true;
363 }
364}
365
366raw_fd_ostream::~raw_fd_ostream() {
Chris Lattner17e9edc2009-08-23 02:51:22 +0000367 if (FD < 0) return;
368 flush();
369 if (ShouldClose)
370 if (::close(FD) != 0)
371 error_detected();
Chris Lattner60d39622008-08-17 01:35:29 +0000372}
373
Chris Lattner17e9edc2009-08-23 02:51:22 +0000374
Dan Gohmanad60f662009-07-16 15:24:40 +0000375void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
Ted Kremenek43d1f022008-10-23 23:49:09 +0000376 assert (FD >= 0 && "File already closed.");
Daniel Dunbar89a66a92009-03-16 23:29:31 +0000377 pos += Size;
Daniel Dunbar579fb872009-07-15 08:11:46 +0000378 if (::write(FD, Ptr, Size) != (ssize_t) Size)
Dan Gohmane87b2ab2009-07-15 23:25:33 +0000379 error_detected();
Chris Lattner60d39622008-08-17 01:35:29 +0000380}
381
Ted Kremenek43d1f022008-10-23 23:49:09 +0000382void raw_fd_ostream::close() {
383 assert (ShouldClose);
384 ShouldClose = false;
385 flush();
Dan Gohmand3a974f2009-07-15 16:43:01 +0000386 if (::close(FD) != 0)
Dan Gohmane87b2ab2009-07-15 23:25:33 +0000387 error_detected();
Ted Kremenek43d1f022008-10-23 23:49:09 +0000388 FD = -1;
389}
390
Ted Kremenek9c278862009-01-26 21:42:04 +0000391uint64_t raw_fd_ostream::seek(uint64_t off) {
392 flush();
Daniel Dunbar579fb872009-07-15 08:11:46 +0000393 pos = ::lseek(FD, off, SEEK_SET);
Dan Gohmand3a974f2009-07-15 16:43:01 +0000394 if (pos != off)
Dan Gohmane87b2ab2009-07-15 23:25:33 +0000395 error_detected();
Ted Kremenek9c278862009-01-26 21:42:04 +0000396 return pos;
397}
398
Dan Gohman208ec0f2009-08-13 17:27:29 +0000399size_t raw_fd_ostream::preferred_buffer_size() {
Dan Gohmanb4741a72009-08-15 21:41:03 +0000400#if !defined(_MSC_VER) && !defined(__MINGW32__) // Windows has no st_blksize.
Dan Gohman208ec0f2009-08-13 17:27:29 +0000401 assert(FD >= 0 && "File not yet open!");
402 struct stat statbuf;
Dan Gohmand7be6632009-08-15 02:05:19 +0000403 if (fstat(FD, &statbuf) == 0) {
404 // If this is a terminal, don't use buffering. Line buffering
405 // would be a more traditional thing to do, but it's not worth
406 // the complexity.
407 if (S_ISCHR(statbuf.st_mode) && isatty(FD))
408 return 0;
409 // Return the preferred block size.
Dan Gohman208ec0f2009-08-13 17:27:29 +0000410 return statbuf.st_blksize;
Dan Gohmand7be6632009-08-15 02:05:19 +0000411 }
Dan Gohman208ec0f2009-08-13 17:27:29 +0000412 error_detected();
413#endif
414 return raw_ostream::preferred_buffer_size();
415}
416
Torok Edwine8ebb0f2009-06-04 07:09:50 +0000417raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold,
418 bool bg) {
419 if (sys::Process::ColorNeedsFlush())
420 flush();
421 const char *colorcode =
422 (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
423 : sys::Process::OutputColor(colors, bold, bg);
424 if (colorcode) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000425 size_t len = strlen(colorcode);
Torok Edwine8ebb0f2009-06-04 07:09:50 +0000426 write(colorcode, len);
427 // don't account colors towards output characters
428 pos -= len;
429 }
430 return *this;
431}
432
433raw_ostream &raw_fd_ostream::resetColor() {
434 if (sys::Process::ColorNeedsFlush())
435 flush();
436 const char *colorcode = sys::Process::ResetColor();
437 if (colorcode) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000438 size_t len = strlen(colorcode);
Torok Edwine8ebb0f2009-06-04 07:09:50 +0000439 write(colorcode, len);
440 // don't account colors towards output characters
441 pos -= len;
442 }
443 return *this;
444}
445
Chris Lattner07f51f72008-08-17 04:13:37 +0000446//===----------------------------------------------------------------------===//
447// raw_stdout/err_ostream
448//===----------------------------------------------------------------------===//
Chris Lattner60d39622008-08-17 01:35:29 +0000449
Dan Gohmanec9b2612009-08-13 23:18:56 +0000450// Set buffer settings to model stdout and stderr behavior.
Dan Gohmand7be6632009-08-15 02:05:19 +0000451// Set standard error to be unbuffered by default.
452raw_stdout_ostream::raw_stdout_ostream():raw_fd_ostream(STDOUT_FILENO, false) {}
453raw_stderr_ostream::raw_stderr_ostream():raw_fd_ostream(STDERR_FILENO, false,
Daniel Dunbare77e4342009-03-10 16:21:55 +0000454 true) {}
Chris Lattner60d39622008-08-17 01:35:29 +0000455
456// An out of line virtual method to provide a home for the class vtable.
457void raw_stdout_ostream::handle() {}
458void raw_stderr_ostream::handle() {}
Chris Lattner07f51f72008-08-17 04:13:37 +0000459
460/// outs() - This returns a reference to a raw_ostream for standard output.
461/// Use it like: outs() << "foo" << "bar";
Owen Andersoncb371882008-08-21 00:14:44 +0000462raw_ostream &llvm::outs() {
Chris Lattner07f51f72008-08-17 04:13:37 +0000463 static raw_stdout_ostream S;
464 return S;
465}
466
467/// errs() - This returns a reference to a raw_ostream for standard error.
468/// Use it like: errs() << "foo" << "bar";
Owen Andersoncb371882008-08-21 00:14:44 +0000469raw_ostream &llvm::errs() {
Chris Lattner07f51f72008-08-17 04:13:37 +0000470 static raw_stderr_ostream S;
471 return S;
472}
473
Daniel Dunbar34ccf032009-07-16 21:17:53 +0000474/// nulls() - This returns a reference to a raw_ostream which discards output.
475raw_ostream &llvm::nulls() {
476 static raw_null_ostream S;
477 return S;
478}
479
Chris Lattner07f51f72008-08-17 04:13:37 +0000480//===----------------------------------------------------------------------===//
481// raw_os_ostream
482//===----------------------------------------------------------------------===//
483
Daniel Dunbar35979c02009-08-18 20:07:36 +0000484raw_os_ostream::~raw_os_ostream() {
485 flush();
486}
487
Dan Gohmanad60f662009-07-16 15:24:40 +0000488void raw_os_ostream::write_impl(const char *Ptr, size_t Size) {
Daniel Dunbar89a66a92009-03-16 23:29:31 +0000489 OS.write(Ptr, Size);
Chris Lattner07f51f72008-08-17 04:13:37 +0000490}
Chris Lattner78a28122008-08-23 22:43:04 +0000491
Douglas Gregor8f7be472009-04-20 07:34:17 +0000492uint64_t raw_os_ostream::current_pos() { return OS.tellp(); }
493
Chris Lattner78a28122008-08-23 22:43:04 +0000494//===----------------------------------------------------------------------===//
495// raw_string_ostream
496//===----------------------------------------------------------------------===//
497
Daniel Dunbar35979c02009-08-18 20:07:36 +0000498raw_string_ostream::~raw_string_ostream() {
499 flush();
500}
501
Dan Gohmanad60f662009-07-16 15:24:40 +0000502void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
Daniel Dunbar89a66a92009-03-16 23:29:31 +0000503 OS.append(Ptr, Size);
Chris Lattner78a28122008-08-23 22:43:04 +0000504}
505
506//===----------------------------------------------------------------------===//
507// raw_svector_ostream
508//===----------------------------------------------------------------------===//
509
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000510// The raw_svector_ostream implementation uses the SmallVector itself as the
511// buffer for the raw_ostream. We guarantee that the raw_ostream buffer is
512// always pointing past the end of the vector, but within the vector
513// capacity. This allows raw_ostream to write directly into the correct place,
514// and we only need to set the vector size when the data is flushed.
515
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000516raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
Daniel Dunbard14787e2009-08-19 18:40:58 +0000517 // Set up the initial external buffer. We make sure that the buffer has at
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000518 // least 128 bytes free; raw_ostream itself only requires 64, but we want to
519 // make sure that we don't grow the buffer unnecessarily on destruction (when
520 // the data is flushed). See the FIXME below.
Daniel Dunbard14787e2009-08-19 18:40:58 +0000521 OS.reserve(OS.size() + 128);
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000522 SetBuffer(OS.end(), OS.capacity() - OS.size());
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000523}
524
Daniel Dunbar35979c02009-08-18 20:07:36 +0000525raw_svector_ostream::~raw_svector_ostream() {
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000526 // FIXME: Prevent resizing during this flush().
Daniel Dunbar35979c02009-08-18 20:07:36 +0000527 flush();
528}
529
Dan Gohmanad60f662009-07-16 15:24:40 +0000530void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000531 assert(Ptr == OS.end() && OS.size() + Size <= OS.capacity() &&
532 "Invalid write_impl() call!");
533
534 // We don't need to copy the bytes, just commit the bytes to the
535 // SmallVector.
536 OS.set_size(OS.size() + Size);
537
538 // Grow the vector if necessary.
539 if (OS.capacity() - OS.size() < 64)
540 OS.reserve(OS.capacity() * 2);
541
542 // Update the buffer position.
543 SetBuffer(OS.end(), OS.capacity() - OS.size());
Chris Lattner78a28122008-08-23 22:43:04 +0000544}
545
Douglas Gregor8f7be472009-04-20 07:34:17 +0000546uint64_t raw_svector_ostream::current_pos() { return OS.size(); }
547
Daniel Dunbard14787e2009-08-19 18:40:58 +0000548StringRef raw_svector_ostream::str() {
549 flush();
550 return StringRef(OS.begin(), OS.size());
551}
552
Daniel Dunbar34ccf032009-07-16 21:17:53 +0000553//===----------------------------------------------------------------------===//
554// raw_null_ostream
555//===----------------------------------------------------------------------===//
556
Dan Gohmanf78c8352009-07-27 21:46:02 +0000557raw_null_ostream::~raw_null_ostream() {
558#ifndef NDEBUG
559 // ~raw_ostream asserts that the buffer is empty. This isn't necessary
560 // with raw_null_ostream, but it's better to have raw_null_ostream follow
561 // the rules than to change the rules just for raw_null_ostream.
562 flush();
563#endif
564}
565
Daniel Dunbar34ccf032009-07-16 21:17:53 +0000566void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
567}
568
569uint64_t raw_null_ostream::current_pos() {
570 return 0;
571}