]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
1 | //===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===// |
2 | // | |
3 | // The LLVM Compiler Infrastructure | |
4 | // | |
5 | // This file is distributed under the University of Illinois Open Source | |
6 | // License. See LICENSE.TXT for details. | |
7 | // | |
8 | //===----------------------------------------------------------------------===// | |
9 | // | |
10 | // This implements support for bulk buffered stream output. | |
11 | // | |
12 | //===----------------------------------------------------------------------===// | |
13 | ||
14 | #include "llvm/Support/raw_ostream.h" | |
970d7e83 | 15 | #include "llvm/ADT/STLExtras.h" |
223e47cc | 16 | #include "llvm/ADT/SmallVector.h" |
970d7e83 | 17 | #include "llvm/ADT/StringExtras.h" |
223e47cc LB |
18 | #include "llvm/Config/config.h" |
19 | #include "llvm/Support/Compiler.h" | |
20 | #include "llvm/Support/ErrorHandling.h" | |
1a4d82fc | 21 | #include "llvm/Support/FileSystem.h" |
970d7e83 | 22 | #include "llvm/Support/Format.h" |
1a4d82fc | 23 | #include "llvm/Support/MathExtras.h" |
970d7e83 LB |
24 | #include "llvm/Support/Process.h" |
25 | #include "llvm/Support/Program.h" | |
223e47cc LB |
26 | #include <cctype> |
27 | #include <cerrno> | |
28 | #include <sys/stat.h> | |
1a4d82fc | 29 | #include <system_error> |
223e47cc | 30 | |
1a4d82fc | 31 | // <fcntl.h> may provide O_BINARY. |
223e47cc LB |
32 | #if defined(HAVE_FCNTL_H) |
33 | # include <fcntl.h> | |
34 | #endif | |
1a4d82fc JJ |
35 | |
36 | #if defined(HAVE_UNISTD_H) | |
37 | # include <unistd.h> | |
38 | #endif | |
223e47cc LB |
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> | |
223e47cc LB |
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 | ||
62 | raw_ostream::~raw_ostream() { | |
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 | ||
75 | size_t raw_ostream::preferred_buffer_size() const { | |
76 | // BUFSIZ is intended to be a reasonable default. | |
77 | return BUFSIZ; | |
78 | } | |
79 | ||
80 | void raw_ostream::SetBuffered() { | |
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) { | |
1a4d82fc JJ |
91 | assert(((Mode == Unbuffered && !BufferStart && Size == 0) || |
92 | (Mode != Unbuffered && BufferStart && Size != 0)) && | |
223e47cc LB |
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 | ||
108 | raw_ostream &raw_ostream::operator<<(unsigned long N) { | |
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 | ||
124 | raw_ostream &raw_ostream::operator<<(long N) { | |
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 | ||
150 | raw_ostream &raw_ostream::operator<<(long long N) { | |
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 | ||
178 | raw_ostream &raw_ostream::write_escaped(StringRef Str, | |
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 | ||
220 | raw_ostream &raw_ostream::operator<<(const void *P) { | |
221 | *this << '0' << 'x'; | |
222 | ||
223 | return write_hex((uintptr_t) P); | |
224 | } | |
225 | ||
226 | raw_ostream &raw_ostream::operator<<(double N) { | |
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! | |
1a4d82fc JJ |
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 | |
223e47cc LB |
236 | int fpcl = _fpclass(N); |
237 | ||
238 | // negative zero | |
239 | if (fpcl == _FPCLASS_NZ) | |
240 | return *this << "-0.000000e+00"; | |
1a4d82fc | 241 | #endif |
223e47cc LB |
242 | |
243 | char buf[16]; | |
244 | unsigned len; | |
245 | len = snprintf(buf, sizeof(buf), "%e", N); | |
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]; | |
970d7e83 LB |
252 | if (isdigit(static_cast<unsigned char>(c1)) && |
253 | isdigit(static_cast<unsigned char>(c0))) { | |
223e47cc LB |
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 | size_t BytesToWrite = Size - (Size % NumBytes); | |
316 | write_impl(Ptr, BytesToWrite); | |
970d7e83 LB |
317 | size_t BytesRemaining = Size - BytesToWrite; |
318 | if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) { | |
319 | // Too much left over to copy into our buffer. | |
320 | return write(Ptr + BytesToWrite, BytesRemaining); | |
321 | } | |
322 | copy_to_buffer(Ptr + BytesToWrite, BytesRemaining); | |
223e47cc LB |
323 | return *this; |
324 | } | |
325 | ||
326 | // We don't have enough space in the buffer to fit the string in. Insert as | |
327 | // much as possible, flush and start over with the remainder. | |
328 | copy_to_buffer(Ptr, NumBytes); | |
329 | flush_nonempty(); | |
330 | return write(Ptr + NumBytes, Size - NumBytes); | |
331 | } | |
332 | ||
333 | copy_to_buffer(Ptr, Size); | |
334 | ||
335 | return *this; | |
336 | } | |
337 | ||
338 | void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { | |
339 | assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!"); | |
340 | ||
341 | // Handle short strings specially, memcpy isn't very good at very short | |
342 | // strings. | |
343 | switch (Size) { | |
344 | case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH | |
345 | case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH | |
346 | case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH | |
347 | case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH | |
348 | case 0: break; | |
349 | default: | |
350 | memcpy(OutBufCur, Ptr, Size); | |
351 | break; | |
352 | } | |
353 | ||
354 | OutBufCur += Size; | |
355 | } | |
356 | ||
357 | // Formatted output. | |
358 | raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { | |
359 | // If we have more than a few bytes left in our output buffer, try | |
360 | // formatting directly onto its end. | |
361 | size_t NextBufferSize = 127; | |
362 | size_t BufferBytesLeft = OutBufEnd - OutBufCur; | |
363 | if (BufferBytesLeft > 3) { | |
364 | size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft); | |
365 | ||
366 | // Common case is that we have plenty of space. | |
367 | if (BytesUsed <= BufferBytesLeft) { | |
368 | OutBufCur += BytesUsed; | |
369 | return *this; | |
370 | } | |
371 | ||
372 | // Otherwise, we overflowed and the return value tells us the size to try | |
373 | // again with. | |
374 | NextBufferSize = BytesUsed; | |
375 | } | |
376 | ||
377 | // If we got here, we didn't have enough space in the output buffer for the | |
378 | // string. Try printing into a SmallVector that is resized to have enough | |
379 | // space. Iterate until we win. | |
380 | SmallVector<char, 128> V; | |
381 | ||
382 | while (1) { | |
383 | V.resize(NextBufferSize); | |
384 | ||
385 | // Try formatting into the SmallVector. | |
386 | size_t BytesUsed = Fmt.print(V.data(), NextBufferSize); | |
387 | ||
388 | // If BytesUsed fit into the vector, we win. | |
389 | if (BytesUsed <= NextBufferSize) | |
390 | return write(V.data(), BytesUsed); | |
391 | ||
392 | // Otherwise, try again with a new size. | |
393 | assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?"); | |
394 | NextBufferSize = BytesUsed; | |
395 | } | |
396 | } | |
397 | ||
1a4d82fc JJ |
398 | raw_ostream &raw_ostream::operator<<(const FormattedString &FS) { |
399 | unsigned Len = FS.Str.size(); | |
400 | int PadAmount = FS.Width - Len; | |
401 | if (FS.RightJustify && (PadAmount > 0)) | |
402 | this->indent(PadAmount); | |
403 | this->operator<<(FS.Str); | |
404 | if (!FS.RightJustify && (PadAmount > 0)) | |
405 | this->indent(PadAmount); | |
406 | return *this; | |
407 | } | |
408 | ||
409 | raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) { | |
410 | if (FN.Hex) { | |
411 | unsigned Nibbles = (64 - countLeadingZeros(FN.HexValue)+3)/4; | |
412 | unsigned Width = (FN.Width > Nibbles+2) ? FN.Width : Nibbles+2; | |
413 | ||
414 | char NumberBuffer[20] = "0x0000000000000000"; | |
415 | char *EndPtr = NumberBuffer+Width; | |
416 | char *CurPtr = EndPtr; | |
417 | const char A = FN.Upper ? 'A' : 'a'; | |
418 | unsigned long long N = FN.HexValue; | |
419 | while (N) { | |
420 | uintptr_t x = N % 16; | |
421 | *--CurPtr = (x < 10 ? '0' + x : A + x - 10); | |
422 | N /= 16; | |
423 | } | |
424 | ||
425 | return write(NumberBuffer, Width); | |
426 | } else { | |
427 | // Zero is a special case. | |
428 | if (FN.DecValue == 0) { | |
429 | this->indent(FN.Width-1); | |
430 | return *this << '0'; | |
431 | } | |
432 | char NumberBuffer[32]; | |
433 | char *EndPtr = NumberBuffer+sizeof(NumberBuffer); | |
434 | char *CurPtr = EndPtr; | |
435 | bool Neg = (FN.DecValue < 0); | |
436 | uint64_t N = Neg ? -static_cast<uint64_t>(FN.DecValue) : FN.DecValue; | |
437 | while (N) { | |
438 | *--CurPtr = '0' + char(N % 10); | |
439 | N /= 10; | |
440 | } | |
441 | int Len = EndPtr - CurPtr; | |
442 | int Pad = FN.Width - Len; | |
443 | if (Neg) | |
444 | --Pad; | |
445 | if (Pad > 0) | |
446 | this->indent(Pad); | |
447 | if (Neg) | |
448 | *this << '-'; | |
449 | return write(CurPtr, Len); | |
450 | } | |
451 | } | |
452 | ||
453 | ||
223e47cc LB |
454 | /// indent - Insert 'NumSpaces' spaces. |
455 | raw_ostream &raw_ostream::indent(unsigned NumSpaces) { | |
456 | static const char Spaces[] = " " | |
457 | " " | |
458 | " "; | |
459 | ||
460 | // Usually the indentation is small, handle it with a fastpath. | |
461 | if (NumSpaces < array_lengthof(Spaces)) | |
462 | return write(Spaces, NumSpaces); | |
463 | ||
464 | while (NumSpaces) { | |
465 | unsigned NumToWrite = std::min(NumSpaces, | |
466 | (unsigned)array_lengthof(Spaces)-1); | |
467 | write(Spaces, NumToWrite); | |
468 | NumSpaces -= NumToWrite; | |
469 | } | |
470 | return *this; | |
471 | } | |
472 | ||
473 | ||
474 | //===----------------------------------------------------------------------===// | |
475 | // Formatted Output | |
476 | //===----------------------------------------------------------------------===// | |
477 | ||
478 | // Out of line virtual method. | |
479 | void format_object_base::home() { | |
480 | } | |
481 | ||
482 | //===----------------------------------------------------------------------===// | |
483 | // raw_fd_ostream | |
484 | //===----------------------------------------------------------------------===// | |
485 | ||
1a4d82fc JJ |
486 | raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC, |
487 | sys::fs::OpenFlags Flags) | |
488 | : Error(false), UseAtomicWrites(false), pos(0) { | |
489 | EC = std::error_code(); | |
223e47cc LB |
490 | // Handle "-" as stdout. Note that when we do this, we consider ourself |
491 | // the owner of stdout. This means that we can do things like close the | |
492 | // file descriptor when we're done and set the "binary" flag globally. | |
1a4d82fc | 493 | if (Filename == "-") { |
223e47cc LB |
494 | FD = STDOUT_FILENO; |
495 | // If user requested binary then put stdout into binary mode if | |
496 | // possible. | |
1a4d82fc JJ |
497 | if (!(Flags & sys::fs::F_Text)) |
498 | sys::ChangeStdoutToBinary(); | |
223e47cc LB |
499 | // Close stdout when we're done, to detect any output errors. |
500 | ShouldClose = true; | |
501 | return; | |
502 | } | |
503 | ||
1a4d82fc | 504 | EC = sys::fs::openFileForWrite(Filename, FD, Flags); |
223e47cc | 505 | |
1a4d82fc JJ |
506 | if (EC) { |
507 | ShouldClose = false; | |
508 | return; | |
223e47cc LB |
509 | } |
510 | ||
511 | // Ok, we successfully opened the file, so it'll need to be closed. | |
512 | ShouldClose = true; | |
513 | } | |
514 | ||
515 | /// raw_fd_ostream ctor - FD is the file descriptor that this writes to. If | |
516 | /// ShouldClose is true, this closes the file when the stream is destroyed. | |
517 | raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered) | |
518 | : raw_ostream(unbuffered), FD(fd), | |
519 | ShouldClose(shouldClose), Error(false), UseAtomicWrites(false) { | |
520 | #ifdef O_BINARY | |
1a4d82fc | 521 | // Setting STDOUT to binary mode is necessary in Win32 |
223e47cc | 522 | // to avoid undesirable linefeed conversion. |
1a4d82fc JJ |
523 | // Don't touch STDERR, or w*printf() (in assert()) would barf wide chars. |
524 | if (fd == STDOUT_FILENO) | |
223e47cc LB |
525 | setmode(fd, O_BINARY); |
526 | #endif | |
527 | ||
528 | // Get the starting position. | |
529 | off_t loc = ::lseek(FD, 0, SEEK_CUR); | |
530 | if (loc == (off_t)-1) | |
531 | pos = 0; | |
532 | else | |
533 | pos = static_cast<uint64_t>(loc); | |
534 | } | |
535 | ||
536 | raw_fd_ostream::~raw_fd_ostream() { | |
537 | if (FD >= 0) { | |
538 | flush(); | |
539 | if (ShouldClose) | |
540 | while (::close(FD) != 0) | |
541 | if (errno != EINTR) { | |
542 | error_detected(); | |
543 | break; | |
544 | } | |
545 | } | |
546 | ||
547 | #ifdef __MINGW32__ | |
548 | // On mingw, global dtors should not call exit(). | |
549 | // report_fatal_error() invokes exit(). We know report_fatal_error() | |
550 | // might not write messages to stderr when any errors were detected | |
551 | // on FD == 2. | |
552 | if (FD == 2) return; | |
553 | #endif | |
554 | ||
555 | // If there are any pending errors, report them now. Clients wishing | |
556 | // to avoid report_fatal_error calls should check for errors with | |
557 | // has_error() and clear the error flag with clear_error() before | |
558 | // destructing raw_ostream objects which may have errors. | |
559 | if (has_error()) | |
1a4d82fc | 560 | report_fatal_error("IO failure on output stream.", /*GenCrashDiag=*/false); |
223e47cc LB |
561 | } |
562 | ||
563 | ||
564 | void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { | |
565 | assert(FD >= 0 && "File already closed."); | |
566 | pos += Size; | |
567 | ||
568 | do { | |
569 | ssize_t ret; | |
570 | ||
571 | // Check whether we should attempt to use atomic writes. | |
572 | if (LLVM_LIKELY(!UseAtomicWrites)) { | |
573 | ret = ::write(FD, Ptr, Size); | |
574 | } else { | |
575 | // Use ::writev() where available. | |
576 | #if defined(HAVE_WRITEV) | |
577 | const void *Addr = static_cast<const void *>(Ptr); | |
578 | struct iovec IOV = {const_cast<void *>(Addr), Size }; | |
579 | ret = ::writev(FD, &IOV, 1); | |
580 | #else | |
581 | ret = ::write(FD, Ptr, Size); | |
582 | #endif | |
583 | } | |
584 | ||
585 | if (ret < 0) { | |
586 | // If it's a recoverable error, swallow it and retry the write. | |
587 | // | |
588 | // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since | |
589 | // raw_ostream isn't designed to do non-blocking I/O. However, some | |
590 | // programs, such as old versions of bjam, have mistakenly used | |
591 | // O_NONBLOCK. For compatibility, emulate blocking semantics by | |
592 | // spinning until the write succeeds. If you don't want spinning, | |
593 | // don't use O_NONBLOCK file descriptors with raw_ostream. | |
594 | if (errno == EINTR || errno == EAGAIN | |
595 | #ifdef EWOULDBLOCK | |
596 | || errno == EWOULDBLOCK | |
597 | #endif | |
598 | ) | |
599 | continue; | |
600 | ||
601 | // Otherwise it's a non-recoverable error. Note it and quit. | |
602 | error_detected(); | |
603 | break; | |
604 | } | |
605 | ||
606 | // The write may have written some or all of the data. Update the | |
607 | // size and buffer pointer to reflect the remainder that needs | |
608 | // to be written. If there are no bytes left, we're done. | |
609 | Ptr += ret; | |
610 | Size -= ret; | |
611 | } while (Size > 0); | |
612 | } | |
613 | ||
614 | void raw_fd_ostream::close() { | |
615 | assert(ShouldClose); | |
616 | ShouldClose = false; | |
617 | flush(); | |
618 | while (::close(FD) != 0) | |
619 | if (errno != EINTR) { | |
620 | error_detected(); | |
621 | break; | |
622 | } | |
623 | FD = -1; | |
624 | } | |
625 | ||
626 | uint64_t raw_fd_ostream::seek(uint64_t off) { | |
627 | flush(); | |
628 | pos = ::lseek(FD, off, SEEK_SET); | |
629 | if (pos != off) | |
630 | error_detected(); | |
631 | return pos; | |
632 | } | |
633 | ||
634 | size_t raw_fd_ostream::preferred_buffer_size() const { | |
635 | #if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix) | |
636 | // Windows and Minix have no st_blksize. | |
637 | assert(FD >= 0 && "File not yet open!"); | |
638 | struct stat statbuf; | |
639 | if (fstat(FD, &statbuf) != 0) | |
640 | return 0; | |
641 | ||
642 | // If this is a terminal, don't use buffering. Line buffering | |
643 | // would be a more traditional thing to do, but it's not worth | |
644 | // the complexity. | |
645 | if (S_ISCHR(statbuf.st_mode) && isatty(FD)) | |
646 | return 0; | |
647 | // Return the preferred block size. | |
648 | return statbuf.st_blksize; | |
649 | #else | |
650 | return raw_ostream::preferred_buffer_size(); | |
651 | #endif | |
652 | } | |
653 | ||
654 | raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold, | |
655 | bool bg) { | |
656 | if (sys::Process::ColorNeedsFlush()) | |
657 | flush(); | |
658 | const char *colorcode = | |
659 | (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg) | |
660 | : sys::Process::OutputColor(colors, bold, bg); | |
661 | if (colorcode) { | |
662 | size_t len = strlen(colorcode); | |
663 | write(colorcode, len); | |
664 | // don't account colors towards output characters | |
665 | pos -= len; | |
666 | } | |
667 | return *this; | |
668 | } | |
669 | ||
670 | raw_ostream &raw_fd_ostream::resetColor() { | |
671 | if (sys::Process::ColorNeedsFlush()) | |
672 | flush(); | |
673 | const char *colorcode = sys::Process::ResetColor(); | |
674 | if (colorcode) { | |
675 | size_t len = strlen(colorcode); | |
676 | write(colorcode, len); | |
677 | // don't account colors towards output characters | |
678 | pos -= len; | |
679 | } | |
680 | return *this; | |
681 | } | |
682 | ||
683 | raw_ostream &raw_fd_ostream::reverseColor() { | |
684 | if (sys::Process::ColorNeedsFlush()) | |
685 | flush(); | |
686 | const char *colorcode = sys::Process::OutputReverse(); | |
687 | if (colorcode) { | |
688 | size_t len = strlen(colorcode); | |
689 | write(colorcode, len); | |
690 | // don't account colors towards output characters | |
691 | pos -= len; | |
692 | } | |
693 | return *this; | |
694 | } | |
695 | ||
696 | bool raw_fd_ostream::is_displayed() const { | |
697 | return sys::Process::FileDescriptorIsDisplayed(FD); | |
698 | } | |
699 | ||
700 | bool raw_fd_ostream::has_colors() const { | |
701 | return sys::Process::FileDescriptorHasColors(FD); | |
702 | } | |
703 | ||
704 | //===----------------------------------------------------------------------===// | |
705 | // outs(), errs(), nulls() | |
706 | //===----------------------------------------------------------------------===// | |
707 | ||
708 | /// outs() - This returns a reference to a raw_ostream for standard output. | |
709 | /// Use it like: outs() << "foo" << "bar"; | |
710 | raw_ostream &llvm::outs() { | |
711 | // Set buffer settings to model stdout behavior. | |
1a4d82fc | 712 | // Delete the file descriptor when the program exits, forcing error |
223e47cc LB |
713 | // detection. If you don't want this behavior, don't use outs(). |
714 | static raw_fd_ostream S(STDOUT_FILENO, true); | |
715 | return S; | |
716 | } | |
717 | ||
718 | /// errs() - This returns a reference to a raw_ostream for standard error. | |
719 | /// Use it like: errs() << "foo" << "bar"; | |
720 | raw_ostream &llvm::errs() { | |
721 | // Set standard error to be unbuffered by default. | |
722 | static raw_fd_ostream S(STDERR_FILENO, false, true); | |
723 | return S; | |
724 | } | |
725 | ||
726 | /// nulls() - This returns a reference to a raw_ostream which discards output. | |
727 | raw_ostream &llvm::nulls() { | |
728 | static raw_null_ostream S; | |
729 | return S; | |
730 | } | |
731 | ||
732 | ||
733 | //===----------------------------------------------------------------------===// | |
734 | // raw_string_ostream | |
735 | //===----------------------------------------------------------------------===// | |
736 | ||
737 | raw_string_ostream::~raw_string_ostream() { | |
738 | flush(); | |
739 | } | |
740 | ||
741 | void raw_string_ostream::write_impl(const char *Ptr, size_t Size) { | |
742 | OS.append(Ptr, Size); | |
743 | } | |
744 | ||
745 | //===----------------------------------------------------------------------===// | |
746 | // raw_svector_ostream | |
747 | //===----------------------------------------------------------------------===// | |
748 | ||
749 | // The raw_svector_ostream implementation uses the SmallVector itself as the | |
750 | // buffer for the raw_ostream. We guarantee that the raw_ostream buffer is | |
751 | // always pointing past the end of the vector, but within the vector | |
752 | // capacity. This allows raw_ostream to write directly into the correct place, | |
753 | // and we only need to set the vector size when the data is flushed. | |
754 | ||
755 | raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) { | |
756 | // Set up the initial external buffer. We make sure that the buffer has at | |
757 | // least 128 bytes free; raw_ostream itself only requires 64, but we want to | |
758 | // make sure that we don't grow the buffer unnecessarily on destruction (when | |
759 | // the data is flushed). See the FIXME below. | |
760 | OS.reserve(OS.size() + 128); | |
761 | SetBuffer(OS.end(), OS.capacity() - OS.size()); | |
762 | } | |
763 | ||
764 | raw_svector_ostream::~raw_svector_ostream() { | |
765 | // FIXME: Prevent resizing during this flush(). | |
766 | flush(); | |
767 | } | |
768 | ||
769 | /// resync - This is called when the SmallVector we're appending to is changed | |
770 | /// outside of the raw_svector_ostream's control. It is only safe to do this | |
771 | /// if the raw_svector_ostream has previously been flushed. | |
772 | void raw_svector_ostream::resync() { | |
773 | assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector"); | |
774 | ||
775 | if (OS.capacity() - OS.size() < 64) | |
776 | OS.reserve(OS.capacity() * 2); | |
777 | SetBuffer(OS.end(), OS.capacity() - OS.size()); | |
778 | } | |
779 | ||
780 | void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { | |
223e47cc | 781 | if (Ptr == OS.end()) { |
1a4d82fc JJ |
782 | // Grow the buffer to include the scratch area without copying. |
783 | size_t NewSize = OS.size() + Size; | |
784 | assert(NewSize <= OS.capacity() && "Invalid write_impl() call!"); | |
785 | OS.set_size(NewSize); | |
223e47cc | 786 | } else { |
1a4d82fc JJ |
787 | assert(!GetNumBytesInBuffer()); |
788 | OS.append(Ptr, Ptr + Size); | |
223e47cc LB |
789 | } |
790 | ||
1a4d82fc | 791 | OS.reserve(OS.size() + 64); |
223e47cc LB |
792 | SetBuffer(OS.end(), OS.capacity() - OS.size()); |
793 | } | |
794 | ||
795 | uint64_t raw_svector_ostream::current_pos() const { | |
796 | return OS.size(); | |
797 | } | |
798 | ||
799 | StringRef raw_svector_ostream::str() { | |
800 | flush(); | |
801 | return StringRef(OS.begin(), OS.size()); | |
802 | } | |
803 | ||
804 | //===----------------------------------------------------------------------===// | |
805 | // raw_null_ostream | |
806 | //===----------------------------------------------------------------------===// | |
807 | ||
808 | raw_null_ostream::~raw_null_ostream() { | |
809 | #ifndef NDEBUG | |
810 | // ~raw_ostream asserts that the buffer is empty. This isn't necessary | |
811 | // with raw_null_ostream, but it's better to have raw_null_ostream follow | |
812 | // the rules than to change the rules just for raw_null_ostream. | |
813 | flush(); | |
814 | #endif | |
815 | } | |
816 | ||
817 | void raw_null_ostream::write_impl(const char *Ptr, size_t Size) { | |
818 | } | |
819 | ||
820 | uint64_t raw_null_ostream::current_pos() const { | |
821 | return 0; | |
822 | } |