blob: 2cb3771287296ee04129746bd70b13563e020468 [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"
Dan Gohman61ee1002009-08-24 04:13:01 +000022#include "llvm/ADT/STLExtras.h"
Chris Lattner23132b12009-08-24 03:52:50 +000023#include "llvm/ADT/StringExtras.h"
Dan Gohman208ec0f2009-08-13 17:27:29 +000024#include <sys/stat.h>
25#include <sys/types.h>
Chris Lattner60d39622008-08-17 01:35:29 +000026
Chris Lattner969a46a2008-08-22 15:45:00 +000027#if defined(HAVE_UNISTD_H)
28# include <unistd.h>
29#endif
30#if defined(HAVE_FCNTL_H)
31# include <fcntl.h>
32#endif
Argyrios Kyrtzidisb68dc362008-08-17 09:25:21 +000033
34#if defined(_MSC_VER)
Chris Lattner60d39622008-08-17 01:35:29 +000035#include <io.h>
Cedric Veneta3f343f2008-08-24 11:56:40 +000036#include <fcntl.h>
Owen Andersoncb371882008-08-21 00:14:44 +000037#ifndef STDIN_FILENO
38# define STDIN_FILENO 0
39#endif
40#ifndef STDOUT_FILENO
41# define STDOUT_FILENO 1
42#endif
43#ifndef STDERR_FILENO
44# define STDERR_FILENO 2
45#endif
Chris Lattner60d39622008-08-17 01:35:29 +000046#endif
47
Chris Lattner969a46a2008-08-22 15:45:00 +000048using namespace llvm;
49
Dan Gohmane87b2ab2009-07-15 23:25:33 +000050raw_ostream::~raw_ostream() {
Dan Gohman9a312542009-07-27 20:49:44 +000051 // raw_ostream's subclasses should take care to flush the buffer
52 // in their destructors.
53 assert(OutBufCur == OutBufStart &&
54 "raw_ostream destructor called with non-empty buffer!");
55
Daniel Dunbar906d5b42009-08-18 23:42:36 +000056 if (BufferMode == InternalBuffer)
57 delete [] OutBufStart;
Dan Gohmane87b2ab2009-07-15 23:25:33 +000058
59 // If there are any pending errors, report them now. Clients wishing
60 // to avoid llvm_report_error calls should check for errors with
61 // has_error() and clear the error flag with clear_error() before
62 // destructing raw_ostream objects which may have errors.
63 if (Error)
64 llvm_report_error("IO failure on output stream.");
65}
Chris Lattner969a46a2008-08-22 15:45:00 +000066
Chris Lattner60d39622008-08-17 01:35:29 +000067// An out of line virtual method to provide a home for the class vtable.
68void raw_ostream::handle() {}
69
Dan Gohman208ec0f2009-08-13 17:27:29 +000070size_t raw_ostream::preferred_buffer_size() {
71 // BUFSIZ is intended to be a reasonable default.
72 return BUFSIZ;
73}
74
75void raw_ostream::SetBuffered() {
76 // Ask the subclass to determine an appropriate buffer size.
Dan Gohmand7be6632009-08-15 02:05:19 +000077 if (size_t Size = preferred_buffer_size())
78 SetBufferSize(Size);
79 else
80 // It may return 0, meaning this stream should be unbuffered.
81 SetUnbuffered();
Dan Gohman208ec0f2009-08-13 17:27:29 +000082}
83
Daniel Dunbar906d5b42009-08-18 23:42:36 +000084void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
85 BufferKind Mode) {
86 assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) ||
87 (Mode != Unbuffered && BufferStart && Size >= 64)) &&
88 "stream must be unbuffered, or have >= 64 bytes of buffer");
89 // Make sure the current buffer is free of content (we can't flush here; the
90 // child buffer management logic will be in write_impl).
91 assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
Dan Gohman524dea42009-08-13 15:58:55 +000092
Daniel Dunbar906d5b42009-08-18 23:42:36 +000093 if (BufferMode == InternalBuffer)
94 delete [] OutBufStart;
95 OutBufStart = BufferStart;
Dan Gohman524dea42009-08-13 15:58:55 +000096 OutBufEnd = OutBufStart+Size;
97 OutBufCur = OutBufStart;
Daniel Dunbar906d5b42009-08-18 23:42:36 +000098 BufferMode = Mode;
Daniel Dunbar425d08c2009-08-19 17:54:29 +000099
100 assert(OutBufStart <= OutBufEnd && "Invalid size!");
Dan Gohman524dea42009-08-13 15:58:55 +0000101}
102
Owen Anderson66b17ba2008-08-21 20:58:52 +0000103raw_ostream &raw_ostream::operator<<(unsigned long N) {
104 // Zero is a special case.
105 if (N == 0)
106 return *this << '0';
107
108 char NumberBuffer[20];
109 char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
110 char *CurPtr = EndPtr;
111
112 while (N) {
113 *--CurPtr = '0' + char(N % 10);
114 N /= 10;
115 }
116 return write(CurPtr, EndPtr-CurPtr);
117}
118
119raw_ostream &raw_ostream::operator<<(long N) {
120 if (N < 0) {
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000121 *this << '-';
Owen Anderson66b17ba2008-08-21 20:58:52 +0000122 N = -N;
123 }
124
125 return this->operator<<(static_cast<unsigned long>(N));
126}
127
128raw_ostream &raw_ostream::operator<<(unsigned long long N) {
Daniel Dunbarecbd0bc2009-08-19 16:25:25 +0000129 // Output using 32-bit div/mod when possible.
Daniel Dunbar78a3dd82009-07-29 06:45:14 +0000130 if (N == static_cast<unsigned long>(N))
131 return this->operator<<(static_cast<unsigned long>(N));
132
Daniel Dunbarecbd0bc2009-08-19 16:25:25 +0000133 char NumberBuffer[20];
134 char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
135 char *CurPtr = EndPtr;
136
137 while (N) {
138 *--CurPtr = '0' + char(N % 10);
139 N /= 10;
140 }
141 return write(CurPtr, EndPtr-CurPtr);
Owen Anderson66b17ba2008-08-21 20:58:52 +0000142}
143
144raw_ostream &raw_ostream::operator<<(long long N) {
145 if (N < 0) {
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000146 *this << '-';
Owen Anderson66b17ba2008-08-21 20:58:52 +0000147 N = -N;
148 }
149
150 return this->operator<<(static_cast<unsigned long long>(N));
151}
152
Daniel Dunbar48018e02009-07-30 18:21:23 +0000153raw_ostream &raw_ostream::write_hex(unsigned long long N) {
Daniel Dunbarb451a0c2009-03-16 22:08:44 +0000154 // Zero is a special case.
155 if (N == 0)
156 return *this << '0';
157
158 char NumberBuffer[20];
159 char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
160 char *CurPtr = EndPtr;
161
162 while (N) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000163 uintptr_t x = N % 16;
Daniel Dunbarb451a0c2009-03-16 22:08:44 +0000164 *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10);
165 N /= 16;
166 }
167
168 return write(CurPtr, EndPtr-CurPtr);
Chris Lattner944fac72008-08-23 22:23:09 +0000169}
170
Daniel Dunbar48018e02009-07-30 18:21:23 +0000171raw_ostream &raw_ostream::operator<<(const void *P) {
172 *this << '0' << 'x';
173
174 return write_hex((uintptr_t) P);
175}
176
Chris Lattner23132b12009-08-24 03:52:50 +0000177raw_ostream &raw_ostream::operator<<(double N) {
178 this->operator<<(ftostr(N));
179 return *this;
180}
181
182
183
Daniel Dunbarcf2a2c62009-03-16 22:55:06 +0000184void raw_ostream::flush_nonempty() {
185 assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000186 size_t Length = OutBufCur - OutBufStart;
187 OutBufCur = OutBufStart;
188 write_impl(OutBufStart, Length);
Daniel Dunbarcf2a2c62009-03-16 22:55:06 +0000189}
190
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000191raw_ostream &raw_ostream::write(unsigned char C) {
Daniel Dunbar262541b2009-03-17 01:36:56 +0000192 // Group exceptional cases into a single branch.
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000193 if (BUILTIN_EXPECT(OutBufCur >= OutBufEnd, false)) {
194 if (BUILTIN_EXPECT(!OutBufStart, false)) {
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000195 if (BufferMode == Unbuffered) {
Dan Gohman37316042009-08-18 20:09:59 +0000196 write_impl(reinterpret_cast<char*>(&C), 1);
197 return *this;
198 }
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000199 // Set up a buffer and start over.
200 SetBuffered();
201 return write(C);
Dan Gohman37316042009-08-18 20:09:59 +0000202 }
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000203
204 flush_nonempty();
Daniel Dunbard17d74b2009-03-17 01:13:35 +0000205 }
206
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000207 *OutBufCur++ = C;
Daniel Dunbarb451a0c2009-03-16 22:08:44 +0000208 return *this;
Daniel Dunbarde75d7f2009-03-16 22:00:17 +0000209}
Chris Lattner944fac72008-08-23 22:23:09 +0000210
Dan Gohmanad60f662009-07-16 15:24:40 +0000211raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
Daniel Dunbar262541b2009-03-17 01:36:56 +0000212 // Group exceptional cases into a single branch.
Daniel Dunbarb372c112009-03-17 21:15:18 +0000213 if (BUILTIN_EXPECT(OutBufCur+Size > OutBufEnd, false)) {
Dan Gohman33e49ef2009-08-13 15:44:52 +0000214 if (BUILTIN_EXPECT(!OutBufStart, false)) {
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000215 if (BufferMode == Unbuffered) {
Dan Gohman33e49ef2009-08-13 15:44:52 +0000216 write_impl(Ptr, Size);
217 return *this;
218 }
219 // Set up a buffer and start over.
Dan Gohman208ec0f2009-08-13 17:27:29 +0000220 SetBuffered();
Dan Gohman33e49ef2009-08-13 15:44:52 +0000221 return write(Ptr, Size);
222 }
Daniel Dunbarecc67e22009-08-19 00:23:39 +0000223
Dan Gohman33e49ef2009-08-13 15:44:52 +0000224 // Write out the data in buffer-sized blocks until the remainder
225 // fits within the buffer.
226 do {
227 size_t NumBytes = OutBufEnd - OutBufCur;
228 copy_to_buffer(Ptr, NumBytes);
Daniel Dunbar262541b2009-03-17 01:36:56 +0000229 flush_nonempty();
Dan Gohman33e49ef2009-08-13 15:44:52 +0000230 Ptr += NumBytes;
231 Size -= NumBytes;
232 } while (OutBufCur+Size > OutBufEnd);
Daniel Dunbar262541b2009-03-17 01:36:56 +0000233 }
Dan Gohman33e49ef2009-08-13 15:44:52 +0000234
235 copy_to_buffer(Ptr, Size);
236
237 return *this;
238}
239
240void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
Dan Gohmanc6126e82009-08-13 20:32:03 +0000241 assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
Dan Gohman4e8e6422009-08-13 18:38:15 +0000242
Owen Anderson66b17ba2008-08-21 20:58:52 +0000243 // Handle short strings specially, memcpy isn't very good at very short
244 // strings.
245 switch (Size) {
246 case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH
247 case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH
248 case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH
249 case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH
250 case 0: break;
251 default:
Dan Gohman33e49ef2009-08-13 15:44:52 +0000252 memcpy(OutBufCur, Ptr, Size);
Owen Anderson66b17ba2008-08-21 20:58:52 +0000253 break;
254 }
Daniel Dunbare77e4342009-03-10 16:21:55 +0000255
Dan Gohman33e49ef2009-08-13 15:44:52 +0000256 OutBufCur += Size;
Owen Anderson66b17ba2008-08-21 20:58:52 +0000257}
258
Chris Lattner097af7f2008-08-23 19:23:10 +0000259// Formatted output.
260raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
Daniel Dunbar262541b2009-03-17 01:36:56 +0000261 // If we have more than a few bytes left in our output buffer, try
262 // formatting directly onto its end.
Dan Gohmanad60f662009-07-16 15:24:40 +0000263 size_t NextBufferSize = 127;
Daniel Dunbar9441cfe2009-08-23 20:31:39 +0000264 size_t BufferBytesLeft = OutBufEnd - OutBufCur;
265 if (BufferBytesLeft > 3) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000266 size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
Chris Lattner097af7f2008-08-23 19:23:10 +0000267
268 // Common case is that we have plenty of space.
Daniel Dunbar9441cfe2009-08-23 20:31:39 +0000269 if (BytesUsed <= BufferBytesLeft) {
Chris Lattner097af7f2008-08-23 19:23:10 +0000270 OutBufCur += BytesUsed;
271 return *this;
272 }
273
274 // Otherwise, we overflowed and the return value tells us the size to try
275 // again with.
276 NextBufferSize = BytesUsed;
277 }
278
279 // If we got here, we didn't have enough space in the output buffer for the
280 // string. Try printing into a SmallVector that is resized to have enough
281 // space. Iterate until we win.
282 SmallVector<char, 128> V;
283
284 while (1) {
285 V.resize(NextBufferSize);
286
287 // Try formatting into the SmallVector.
Daniel Dunbar9441cfe2009-08-23 20:31:39 +0000288 size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
Chris Lattner097af7f2008-08-23 19:23:10 +0000289
290 // If BytesUsed fit into the vector, we win.
Chris Lattnerf61ca1e2008-10-26 19:20:47 +0000291 if (BytesUsed <= NextBufferSize)
Daniel Dunbar9441cfe2009-08-23 20:31:39 +0000292 return write(V.data(), BytesUsed);
Chris Lattner097af7f2008-08-23 19:23:10 +0000293
294 // Otherwise, try again with a new size.
295 assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
296 NextBufferSize = BytesUsed;
297 }
298}
299
Chris Lattnerc5a227d2009-08-22 23:10:29 +0000300/// indent - Insert 'NumSpaces' spaces.
301raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
Dan Gohman61ee1002009-08-24 04:13:01 +0000302 static const char Spaces[] = " "
303 " "
304 " ";
Chris Lattnerc5a227d2009-08-22 23:10:29 +0000305
306 // Usually the indentation is small, handle it with a fastpath.
Dan Gohmancb1308b2009-08-24 04:43:38 +0000307 if (NumSpaces < array_lengthof(Spaces))
Chris Lattnerc5a227d2009-08-22 23:10:29 +0000308 return write(Spaces, NumSpaces);
309
310 while (NumSpaces) {
Dan Gohmancb1308b2009-08-24 04:43:38 +0000311 unsigned NumToWrite = std::min(NumSpaces,
312 (unsigned)array_lengthof(Spaces)-1);
Chris Lattnerc5a227d2009-08-22 23:10:29 +0000313 write(Spaces, NumToWrite);
314 NumSpaces -= NumToWrite;
315 }
316 return *this;
317}
318
319
Chris Lattner097af7f2008-08-23 19:23:10 +0000320//===----------------------------------------------------------------------===//
321// Formatted Output
322//===----------------------------------------------------------------------===//
323
324// Out of line virtual method.
325void format_object_base::home() {
326}
327
Chris Lattner60d39622008-08-17 01:35:29 +0000328//===----------------------------------------------------------------------===//
329// raw_fd_ostream
330//===----------------------------------------------------------------------===//
331
Daniel Dunbar48534b32008-10-21 19:53:10 +0000332/// raw_fd_ostream - Open the specified file for writing. If an error
333/// occurs, information about the error is put into ErrorInfo, and the
334/// stream should be immediately destroyed; the string will be empty
335/// if no error occurred.
Chris Lattner17e9edc2009-08-23 02:51:22 +0000336raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo,
337 unsigned Flags) : pos(0) {
Dan Gohmanbaa26392009-08-25 15:34:52 +0000338 // Verify that we don't have both "append" and "excl".
339 assert((!(Flags & F_Excl) || !(Flags & F_Append)) &&
340 "Cannot specify both 'excl' and 'append' file creation flags!");
Chris Lattner17e9edc2009-08-23 02:51:22 +0000341
Daniel Dunbar48534b32008-10-21 19:53:10 +0000342 ErrorInfo.clear();
343
Chris Lattnerc52b1282008-08-17 03:53:23 +0000344 // Handle "-" as stdout.
345 if (Filename[0] == '-' && Filename[1] == 0) {
346 FD = STDOUT_FILENO;
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000347 // If user requested binary then put stdout into binary mode if
348 // possible.
Chris Lattner17e9edc2009-08-23 02:51:22 +0000349 if (Flags & F_Binary)
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000350 sys::Program::ChangeStdoutToBinary();
Chris Lattnerc52b1282008-08-17 03:53:23 +0000351 ShouldClose = false;
352 return;
353 }
354
Chris Lattner17e9edc2009-08-23 02:51:22 +0000355 int OpenFlags = O_WRONLY|O_CREAT;
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000356#ifdef O_BINARY
Benjamin Kramerae603242009-08-23 08:57:52 +0000357 if (Flags & F_Binary)
Chris Lattner17e9edc2009-08-23 02:51:22 +0000358 OpenFlags |= O_BINARY;
Daniel Dunbar0d9eb9b2008-11-13 05:01:07 +0000359#endif
Chris Lattner17e9edc2009-08-23 02:51:22 +0000360
Dan Gohmanbaa26392009-08-25 15:34:52 +0000361 if (Flags & F_Append)
Chris Lattner17e9edc2009-08-23 02:51:22 +0000362 OpenFlags |= O_APPEND;
363 else
Dan Gohmanbaa26392009-08-25 15:34:52 +0000364 OpenFlags |= O_TRUNC;
365 if (Flags & F_Excl)
Chris Lattner17e9edc2009-08-23 02:51:22 +0000366 OpenFlags |= O_EXCL;
367
368 FD = open(Filename, OpenFlags, 0664);
Chris Lattner60d39622008-08-17 01:35:29 +0000369 if (FD < 0) {
370 ErrorInfo = "Error opening output file '" + std::string(Filename) + "'";
371 ShouldClose = false;
372 } else {
373 ShouldClose = true;
374 }
375}
376
377raw_fd_ostream::~raw_fd_ostream() {
Chris Lattner17e9edc2009-08-23 02:51:22 +0000378 if (FD < 0) return;
379 flush();
380 if (ShouldClose)
381 if (::close(FD) != 0)
382 error_detected();
Chris Lattner60d39622008-08-17 01:35:29 +0000383}
384
Chris Lattner17e9edc2009-08-23 02:51:22 +0000385
Dan Gohmanad60f662009-07-16 15:24:40 +0000386void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
Ted Kremenek43d1f022008-10-23 23:49:09 +0000387 assert (FD >= 0 && "File already closed.");
Daniel Dunbar89a66a92009-03-16 23:29:31 +0000388 pos += Size;
Daniel Dunbar579fb872009-07-15 08:11:46 +0000389 if (::write(FD, Ptr, Size) != (ssize_t) Size)
Dan Gohmane87b2ab2009-07-15 23:25:33 +0000390 error_detected();
Chris Lattner60d39622008-08-17 01:35:29 +0000391}
392
Ted Kremenek43d1f022008-10-23 23:49:09 +0000393void raw_fd_ostream::close() {
394 assert (ShouldClose);
395 ShouldClose = false;
396 flush();
Dan Gohmand3a974f2009-07-15 16:43:01 +0000397 if (::close(FD) != 0)
Dan Gohmane87b2ab2009-07-15 23:25:33 +0000398 error_detected();
Ted Kremenek43d1f022008-10-23 23:49:09 +0000399 FD = -1;
400}
401
Ted Kremenek9c278862009-01-26 21:42:04 +0000402uint64_t raw_fd_ostream::seek(uint64_t off) {
403 flush();
Daniel Dunbar579fb872009-07-15 08:11:46 +0000404 pos = ::lseek(FD, off, SEEK_SET);
Dan Gohmand3a974f2009-07-15 16:43:01 +0000405 if (pos != off)
Dan Gohmane87b2ab2009-07-15 23:25:33 +0000406 error_detected();
Ted Kremenek9c278862009-01-26 21:42:04 +0000407 return pos;
408}
409
Dan Gohman208ec0f2009-08-13 17:27:29 +0000410size_t raw_fd_ostream::preferred_buffer_size() {
Dan Gohmanb4741a72009-08-15 21:41:03 +0000411#if !defined(_MSC_VER) && !defined(__MINGW32__) // Windows has no st_blksize.
Dan Gohman208ec0f2009-08-13 17:27:29 +0000412 assert(FD >= 0 && "File not yet open!");
413 struct stat statbuf;
Dan Gohmand7be6632009-08-15 02:05:19 +0000414 if (fstat(FD, &statbuf) == 0) {
415 // If this is a terminal, don't use buffering. Line buffering
416 // would be a more traditional thing to do, but it's not worth
417 // the complexity.
418 if (S_ISCHR(statbuf.st_mode) && isatty(FD))
419 return 0;
420 // Return the preferred block size.
Dan Gohman208ec0f2009-08-13 17:27:29 +0000421 return statbuf.st_blksize;
Dan Gohmand7be6632009-08-15 02:05:19 +0000422 }
Dan Gohman208ec0f2009-08-13 17:27:29 +0000423 error_detected();
424#endif
425 return raw_ostream::preferred_buffer_size();
426}
427
Torok Edwine8ebb0f2009-06-04 07:09:50 +0000428raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold,
429 bool bg) {
430 if (sys::Process::ColorNeedsFlush())
431 flush();
432 const char *colorcode =
433 (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
434 : sys::Process::OutputColor(colors, bold, bg);
435 if (colorcode) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000436 size_t len = strlen(colorcode);
Torok Edwine8ebb0f2009-06-04 07:09:50 +0000437 write(colorcode, len);
438 // don't account colors towards output characters
439 pos -= len;
440 }
441 return *this;
442}
443
444raw_ostream &raw_fd_ostream::resetColor() {
445 if (sys::Process::ColorNeedsFlush())
446 flush();
447 const char *colorcode = sys::Process::ResetColor();
448 if (colorcode) {
Dan Gohmanad60f662009-07-16 15:24:40 +0000449 size_t len = strlen(colorcode);
Torok Edwine8ebb0f2009-06-04 07:09:50 +0000450 write(colorcode, len);
451 // don't account colors towards output characters
452 pos -= len;
453 }
454 return *this;
455}
456
Dan Gohmanec080462009-09-11 20:46:33 +0000457bool raw_fd_ostream::is_displayed() const {
458 return sys::Process::FileDescriptorIsDisplayed(FD);
459}
460
Chris Lattner07f51f72008-08-17 04:13:37 +0000461//===----------------------------------------------------------------------===//
462// raw_stdout/err_ostream
463//===----------------------------------------------------------------------===//
Chris Lattner60d39622008-08-17 01:35:29 +0000464
Dan Gohmanec9b2612009-08-13 23:18:56 +0000465// Set buffer settings to model stdout and stderr behavior.
Dan Gohmand7be6632009-08-15 02:05:19 +0000466// Set standard error to be unbuffered by default.
467raw_stdout_ostream::raw_stdout_ostream():raw_fd_ostream(STDOUT_FILENO, false) {}
468raw_stderr_ostream::raw_stderr_ostream():raw_fd_ostream(STDERR_FILENO, false,
Daniel Dunbare77e4342009-03-10 16:21:55 +0000469 true) {}
Chris Lattner60d39622008-08-17 01:35:29 +0000470
471// An out of line virtual method to provide a home for the class vtable.
472void raw_stdout_ostream::handle() {}
473void raw_stderr_ostream::handle() {}
Chris Lattner07f51f72008-08-17 04:13:37 +0000474
475/// outs() - This returns a reference to a raw_ostream for standard output.
476/// Use it like: outs() << "foo" << "bar";
Owen Andersoncb371882008-08-21 00:14:44 +0000477raw_ostream &llvm::outs() {
Chris Lattner07f51f72008-08-17 04:13:37 +0000478 static raw_stdout_ostream S;
479 return S;
480}
481
482/// errs() - This returns a reference to a raw_ostream for standard error.
483/// Use it like: errs() << "foo" << "bar";
Owen Andersoncb371882008-08-21 00:14:44 +0000484raw_ostream &llvm::errs() {
Chris Lattner07f51f72008-08-17 04:13:37 +0000485 static raw_stderr_ostream S;
486 return S;
487}
488
Daniel Dunbar34ccf032009-07-16 21:17:53 +0000489/// nulls() - This returns a reference to a raw_ostream which discards output.
490raw_ostream &llvm::nulls() {
491 static raw_null_ostream S;
492 return S;
493}
494
Douglas Gregor8f7be472009-04-20 07:34:17 +0000495
Chris Lattner78a28122008-08-23 22:43:04 +0000496//===----------------------------------------------------------------------===//
497// raw_string_ostream
498//===----------------------------------------------------------------------===//
499
Daniel Dunbar35979c02009-08-18 20:07:36 +0000500raw_string_ostream::~raw_string_ostream() {
501 flush();
502}
503
Dan Gohmanad60f662009-07-16 15:24:40 +0000504void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
Daniel Dunbar89a66a92009-03-16 23:29:31 +0000505 OS.append(Ptr, Size);
Chris Lattner78a28122008-08-23 22:43:04 +0000506}
507
508//===----------------------------------------------------------------------===//
509// raw_svector_ostream
510//===----------------------------------------------------------------------===//
511
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000512// The raw_svector_ostream implementation uses the SmallVector itself as the
513// buffer for the raw_ostream. We guarantee that the raw_ostream buffer is
514// always pointing past the end of the vector, but within the vector
515// capacity. This allows raw_ostream to write directly into the correct place,
516// and we only need to set the vector size when the data is flushed.
517
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000518raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
Daniel Dunbard14787e2009-08-19 18:40:58 +0000519 // Set up the initial external buffer. We make sure that the buffer has at
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000520 // least 128 bytes free; raw_ostream itself only requires 64, but we want to
521 // make sure that we don't grow the buffer unnecessarily on destruction (when
522 // the data is flushed). See the FIXME below.
Daniel Dunbard14787e2009-08-19 18:40:58 +0000523 OS.reserve(OS.size() + 128);
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000524 SetBuffer(OS.end(), OS.capacity() - OS.size());
Daniel Dunbar906d5b42009-08-18 23:42:36 +0000525}
526
Daniel Dunbar35979c02009-08-18 20:07:36 +0000527raw_svector_ostream::~raw_svector_ostream() {
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000528 // FIXME: Prevent resizing during this flush().
Daniel Dunbar35979c02009-08-18 20:07:36 +0000529 flush();
530}
531
Dan Gohmanad60f662009-07-16 15:24:40 +0000532void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
Daniel Dunbar425d08c2009-08-19 17:54:29 +0000533 assert(Ptr == OS.end() && OS.size() + Size <= OS.capacity() &&
534 "Invalid write_impl() call!");
535
536 // We don't need to copy the bytes, just commit the bytes to the
537 // SmallVector.
538 OS.set_size(OS.size() + Size);
539
540 // Grow the vector if necessary.
541 if (OS.capacity() - OS.size() < 64)
542 OS.reserve(OS.capacity() * 2);
543
544 // Update the buffer position.
545 SetBuffer(OS.end(), OS.capacity() - OS.size());
Chris Lattner78a28122008-08-23 22:43:04 +0000546}
547
Douglas Gregor8f7be472009-04-20 07:34:17 +0000548uint64_t raw_svector_ostream::current_pos() { return OS.size(); }
549
Daniel Dunbard14787e2009-08-19 18:40:58 +0000550StringRef raw_svector_ostream::str() {
551 flush();
552 return StringRef(OS.begin(), OS.size());
553}
554
Daniel Dunbar34ccf032009-07-16 21:17:53 +0000555//===----------------------------------------------------------------------===//
556// raw_null_ostream
557//===----------------------------------------------------------------------===//
558
Dan Gohmanf78c8352009-07-27 21:46:02 +0000559raw_null_ostream::~raw_null_ostream() {
560#ifndef NDEBUG
561 // ~raw_ostream asserts that the buffer is empty. This isn't necessary
562 // with raw_null_ostream, but it's better to have raw_null_ostream follow
563 // the rules than to change the rules just for raw_null_ostream.
564 flush();
565#endif
566}
567
Daniel Dunbar34ccf032009-07-16 21:17:53 +0000568void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
569}
570
571uint64_t raw_null_ostream::current_pos() {
572 return 0;
573}