prune the #includes in raw_ostream.h by moving a
[oota-llvm.git] / lib / Support / raw_ostream.cpp
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"
15 #include "llvm/Support/Format.h"
16 #include "llvm/System/Program.h"
17 #include "llvm/System/Process.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/Config/config.h"
20 #include "llvm/Support/Compiler.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include <ostream>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26
27 #if defined(HAVE_UNISTD_H)
28 # include <unistd.h>
29 #endif
30 #if defined(HAVE_FCNTL_H)
31 # include <fcntl.h>
32 #endif
33
34 #if defined(_MSC_VER)
35 #include <io.h>
36 #include <fcntl.h>
37 #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
46 #endif
47
48 using namespace llvm;
49
50 raw_ostream::~raw_ostream() {
51   // 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
56   if (BufferMode == InternalBuffer)
57     delete [] OutBufStart;
58
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 }
66
67 // An out of line virtual method to provide a home for the class vtable.
68 void raw_ostream::handle() {}
69
70 size_t raw_ostream::preferred_buffer_size() {
71   // BUFSIZ is intended to be a reasonable default.
72   return BUFSIZ;
73 }
74
75 void raw_ostream::SetBuffered() {
76   // Ask the subclass to determine an appropriate buffer size.
77   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();
82 }
83
84 void 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!");
92
93   if (BufferMode == InternalBuffer)
94     delete [] OutBufStart;
95   OutBufStart = BufferStart;
96   OutBufEnd = OutBufStart+Size;
97   OutBufCur = OutBufStart;
98   BufferMode = Mode;
99
100   assert(OutBufStart <= OutBufEnd && "Invalid size!");
101 }
102
103 raw_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
119 raw_ostream &raw_ostream::operator<<(long N) {
120   if (N <  0) {
121     *this << '-';
122     N = -N;
123   }
124   
125   return this->operator<<(static_cast<unsigned long>(N));
126 }
127
128 raw_ostream &raw_ostream::operator<<(unsigned long long N) {
129   // Output using 32-bit div/mod when possible.
130   if (N == static_cast<unsigned long>(N))
131     return this->operator<<(static_cast<unsigned long>(N));
132
133   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);
142 }
143
144 raw_ostream &raw_ostream::operator<<(long long N) {
145   if (N <  0) {
146     *this << '-';
147     N = -N;
148   }
149   
150   return this->operator<<(static_cast<unsigned long long>(N));
151 }
152
153 raw_ostream &raw_ostream::write_hex(unsigned long long N) {
154   // 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) {
163     uintptr_t x = N % 16;
164     *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10);
165     N /= 16;
166   }
167
168   return write(CurPtr, EndPtr-CurPtr);
169 }
170
171 raw_ostream &raw_ostream::operator<<(const void *P) {
172   *this << '0' << 'x';
173
174   return write_hex((uintptr_t) P);
175 }
176
177 raw_ostream &raw_ostream::operator<<(double N) {
178   this->operator<<(ftostr(N));
179   return *this;
180 }
181
182
183
184 void raw_ostream::flush_nonempty() {
185   assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
186   size_t Length = OutBufCur - OutBufStart;
187   OutBufCur = OutBufStart;
188   write_impl(OutBufStart, Length);
189 }
190
191 raw_ostream &raw_ostream::write(unsigned char C) {
192   // Group exceptional cases into a single branch.
193   if (BUILTIN_EXPECT(OutBufCur >= OutBufEnd, false)) {
194     if (BUILTIN_EXPECT(!OutBufStart, false)) {
195       if (BufferMode == Unbuffered) {
196         write_impl(reinterpret_cast<char*>(&C), 1);
197         return *this;
198       }
199       // Set up a buffer and start over.
200       SetBuffered();
201       return write(C);
202     }
203
204     flush_nonempty();
205   }
206
207   *OutBufCur++ = C;
208   return *this;
209 }
210
211 raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
212   // Group exceptional cases into a single branch.
213   if (BUILTIN_EXPECT(OutBufCur+Size > OutBufEnd, false)) {
214     if (BUILTIN_EXPECT(!OutBufStart, false)) {
215       if (BufferMode == Unbuffered) {
216         write_impl(Ptr, Size);
217         return *this;
218       }
219       // Set up a buffer and start over.
220       SetBuffered();
221       return write(Ptr, Size);
222     }
223
224     // 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);
229       flush_nonempty();
230       Ptr += NumBytes;
231       Size -= NumBytes;
232     } while (OutBufCur+Size > OutBufEnd);
233   }
234
235   copy_to_buffer(Ptr, Size);
236
237   return *this;
238 }
239
240 void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
241   assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
242
243   // 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:
252     memcpy(OutBufCur, Ptr, Size);
253     break;
254   }
255
256   OutBufCur += Size;
257 }
258
259 // Formatted output.
260 raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
261   // If we have more than a few bytes left in our output buffer, try
262   // formatting directly onto its end.
263   size_t NextBufferSize = 127;
264   size_t BufferBytesLeft = OutBufEnd - OutBufCur;
265   if (BufferBytesLeft > 3) {
266     size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
267     
268     // Common case is that we have plenty of space.
269     if (BytesUsed <= BufferBytesLeft) {
270       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.
288     size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
289     
290     // If BytesUsed fit into the vector, we win.
291     if (BytesUsed <= NextBufferSize)
292       return write(V.data(), BytesUsed);
293     
294     // Otherwise, try again with a new size.
295     assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
296     NextBufferSize = BytesUsed;
297   }
298 }
299
300 /// indent - Insert 'NumSpaces' spaces.
301 raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
302   const char *Spaces = "                ";
303
304   // Usually the indentation is small, handle it with a fastpath.
305   if (NumSpaces <= 16)
306     return write(Spaces, NumSpaces);
307   
308   while (NumSpaces) {
309     unsigned NumToWrite = std::min(NumSpaces, 16U);
310     write(Spaces, NumToWrite);
311     NumSpaces -= NumToWrite;
312   }
313   return *this;
314 }
315
316
317 //===----------------------------------------------------------------------===//
318 //  Formatted Output
319 //===----------------------------------------------------------------------===//
320
321 // Out of line virtual method.
322 void format_object_base::home() {
323 }
324
325 //===----------------------------------------------------------------------===//
326 //  raw_fd_ostream
327 //===----------------------------------------------------------------------===//
328
329 /// raw_fd_ostream - Open the specified file for writing. If an error
330 /// occurs, information about the error is put into ErrorInfo, and the
331 /// stream should be immediately destroyed; the string will be empty
332 /// if no error occurred.
333 raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo,
334                                unsigned Flags) : pos(0) {
335   // Verify that we don't have both "append" and "force".
336   assert((!(Flags & F_Force) || !(Flags & F_Append)) &&
337          "Cannot specify both 'force' and 'append' file creation flags!");
338   
339   ErrorInfo.clear();
340
341   // Handle "-" as stdout.
342   if (Filename[0] == '-' && Filename[1] == 0) {
343     FD = STDOUT_FILENO;
344     // If user requested binary then put stdout into binary mode if
345     // possible.
346     if (Flags & F_Binary)
347       sys::Program::ChangeStdoutToBinary();
348     ShouldClose = false;
349     return;
350   }
351   
352   int OpenFlags = O_WRONLY|O_CREAT;
353 #ifdef O_BINARY
354   if (Flags & F_Binary)
355     OpenFlags |= O_BINARY;
356 #endif
357   
358   if (Flags & F_Force)
359     OpenFlags |= O_TRUNC;
360   else if (Flags & F_Append)
361     OpenFlags |= O_APPEND;
362   else
363     OpenFlags |= O_EXCL;
364   
365   FD = open(Filename, OpenFlags, 0664);
366   if (FD < 0) {
367     ErrorInfo = "Error opening output file '" + std::string(Filename) + "'";
368     ShouldClose = false;
369   } else {
370     ShouldClose = true;
371   }
372 }
373
374 raw_fd_ostream::~raw_fd_ostream() {
375   if (FD < 0) return;
376   flush();
377   if (ShouldClose)
378     if (::close(FD) != 0)
379       error_detected();
380 }
381
382
383 void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
384   assert (FD >= 0 && "File already closed.");
385   pos += Size;
386   if (::write(FD, Ptr, Size) != (ssize_t) Size)
387     error_detected();
388 }
389
390 void raw_fd_ostream::close() {
391   assert (ShouldClose);
392   ShouldClose = false;
393   flush();
394   if (::close(FD) != 0)
395     error_detected();
396   FD = -1;
397 }
398
399 uint64_t raw_fd_ostream::seek(uint64_t off) {
400   flush();
401   pos = ::lseek(FD, off, SEEK_SET);
402   if (pos != off)
403     error_detected();
404   return pos;  
405 }
406
407 size_t raw_fd_ostream::preferred_buffer_size() {
408 #if !defined(_MSC_VER) && !defined(__MINGW32__) // Windows has no st_blksize.
409   assert(FD >= 0 && "File not yet open!");
410   struct stat statbuf;
411   if (fstat(FD, &statbuf) == 0) {
412     // If this is a terminal, don't use buffering. Line buffering
413     // would be a more traditional thing to do, but it's not worth
414     // the complexity.
415     if (S_ISCHR(statbuf.st_mode) && isatty(FD))
416       return 0;
417     // Return the preferred block size.
418     return statbuf.st_blksize;
419   }
420   error_detected();
421 #endif
422   return raw_ostream::preferred_buffer_size();
423 }
424
425 raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold,
426                                          bool bg) {
427   if (sys::Process::ColorNeedsFlush())
428     flush();
429   const char *colorcode =
430     (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
431     : sys::Process::OutputColor(colors, bold, bg);
432   if (colorcode) {
433     size_t len = strlen(colorcode);
434     write(colorcode, len);
435     // don't account colors towards output characters
436     pos -= len;
437   }
438   return *this;
439 }
440
441 raw_ostream &raw_fd_ostream::resetColor() {
442   if (sys::Process::ColorNeedsFlush())
443     flush();
444   const char *colorcode = sys::Process::ResetColor();
445   if (colorcode) {
446     size_t len = strlen(colorcode);
447     write(colorcode, len);
448     // don't account colors towards output characters
449     pos -= len;
450   }
451   return *this;
452 }
453
454 //===----------------------------------------------------------------------===//
455 //  raw_stdout/err_ostream
456 //===----------------------------------------------------------------------===//
457
458 // Set buffer settings to model stdout and stderr behavior.
459 // Set standard error to be unbuffered by default.
460 raw_stdout_ostream::raw_stdout_ostream():raw_fd_ostream(STDOUT_FILENO, false) {}
461 raw_stderr_ostream::raw_stderr_ostream():raw_fd_ostream(STDERR_FILENO, false,
462                                                         true) {}
463
464 // An out of line virtual method to provide a home for the class vtable.
465 void raw_stdout_ostream::handle() {}
466 void raw_stderr_ostream::handle() {}
467
468 /// outs() - This returns a reference to a raw_ostream for standard output.
469 /// Use it like: outs() << "foo" << "bar";
470 raw_ostream &llvm::outs() {
471   static raw_stdout_ostream S;
472   return S;
473 }
474
475 /// errs() - This returns a reference to a raw_ostream for standard error.
476 /// Use it like: errs() << "foo" << "bar";
477 raw_ostream &llvm::errs() {
478   static raw_stderr_ostream S;
479   return S;
480 }
481
482 /// nulls() - This returns a reference to a raw_ostream which discards output.
483 raw_ostream &llvm::nulls() {
484   static raw_null_ostream S;
485   return S;
486 }
487
488 //===----------------------------------------------------------------------===//
489 //  raw_os_ostream
490 //===----------------------------------------------------------------------===//
491
492 raw_os_ostream::~raw_os_ostream() {
493   flush();
494 }
495
496 void raw_os_ostream::write_impl(const char *Ptr, size_t Size) {
497   OS.write(Ptr, Size);
498 }
499
500 uint64_t raw_os_ostream::current_pos() { return OS.tellp(); }
501
502 //===----------------------------------------------------------------------===//
503 //  raw_string_ostream
504 //===----------------------------------------------------------------------===//
505
506 raw_string_ostream::~raw_string_ostream() {
507   flush();
508 }
509
510 void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
511   OS.append(Ptr, Size);
512 }
513
514 //===----------------------------------------------------------------------===//
515 //  raw_svector_ostream
516 //===----------------------------------------------------------------------===//
517
518 // The raw_svector_ostream implementation uses the SmallVector itself as the
519 // buffer for the raw_ostream. We guarantee that the raw_ostream buffer is
520 // always pointing past the end of the vector, but within the vector
521 // capacity. This allows raw_ostream to write directly into the correct place,
522 // and we only need to set the vector size when the data is flushed.
523
524 raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
525   // Set up the initial external buffer. We make sure that the buffer has at
526   // least 128 bytes free; raw_ostream itself only requires 64, but we want to
527   // make sure that we don't grow the buffer unnecessarily on destruction (when
528   // the data is flushed). See the FIXME below.
529   OS.reserve(OS.size() + 128);
530   SetBuffer(OS.end(), OS.capacity() - OS.size());
531 }
532
533 raw_svector_ostream::~raw_svector_ostream() {
534   // FIXME: Prevent resizing during this flush().
535   flush();
536 }
537
538 void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
539   assert(Ptr == OS.end() && OS.size() + Size <= OS.capacity() &&
540          "Invalid write_impl() call!");
541
542   // We don't need to copy the bytes, just commit the bytes to the
543   // SmallVector.
544   OS.set_size(OS.size() + Size);
545
546   // Grow the vector if necessary.
547   if (OS.capacity() - OS.size() < 64)
548     OS.reserve(OS.capacity() * 2);
549
550   // Update the buffer position.
551   SetBuffer(OS.end(), OS.capacity() - OS.size());
552 }
553
554 uint64_t raw_svector_ostream::current_pos() { return OS.size(); }
555
556 StringRef raw_svector_ostream::str() {
557   flush();
558   return StringRef(OS.begin(), OS.size());
559 }
560
561 //===----------------------------------------------------------------------===//
562 //  raw_null_ostream
563 //===----------------------------------------------------------------------===//
564
565 raw_null_ostream::~raw_null_ostream() {
566 #ifndef NDEBUG
567   // ~raw_ostream asserts that the buffer is empty. This isn't necessary
568   // with raw_null_ostream, but it's better to have raw_null_ostream follow
569   // the rules than to change the rules just for raw_null_ostream.
570   flush();
571 #endif
572 }
573
574 void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
575 }
576
577 uint64_t raw_null_ostream::current_pos() {
578   return 0;
579 }