160d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner//===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===// 260d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// 360d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// The LLVM Compiler Infrastructure 460d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// 560d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// This file is distributed under the University of Illinois Open Source 660d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// License. See LICENSE.TXT for details. 760d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// 860d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner//===----------------------------------------------------------------------===// 960d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// 1060d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// This implements support for bulk buffered stream output. 1160d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// 1260d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner//===----------------------------------------------------------------------===// 1360d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 1460d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner#include "llvm/Support/raw_ostream.h" 15d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/STLExtras.h" 16097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner#include "llvm/ADT/SmallVector.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/StringExtras.h" 18969a46a948414734f5bc01994e54d88d153cb3fbChris Lattner#include "llvm/Config/config.h" 19b372c1114c1eeffbd1a3f6ddc5d33e77564bfee2Daniel Dunbar#include "llvm/Support/Compiler.h" 20579fb87ce7c7a407b76fb47da17b605d44db2d17Daniel Dunbar#include "llvm/Support/ErrorHandling.h" 21c1b49b56d4132efa2e06deb8f23508d0de4c8800Rafael Espindola#include "llvm/Support/FileSystem.h" 22d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Format.h" 2337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines#include "llvm/Support/MathExtras.h" 24d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Process.h" 25d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Program.h" 264f17eb87218ce4879a4ef0ed15c9ac5cf0294c2aBenjamin Kramer#include <cctype> 2766760be9195d0f19efc462c080e6d123e862d641Benjamin Kramer#include <cerrno> 28208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman#include <sys/stat.h> 29c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines#include <system_error> 3060d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 31f7e73accb7abe472a1febc38888133df6149cfedNAKAMURA Takumi// <fcntl.h> may provide O_BINARY. 32f7e73accb7abe472a1febc38888133df6149cfedNAKAMURA Takumi#if defined(HAVE_FCNTL_H) 33f7e73accb7abe472a1febc38888133df6149cfedNAKAMURA Takumi# include <fcntl.h> 34f7e73accb7abe472a1febc38888133df6149cfedNAKAMURA Takumi#endif 35f7e73accb7abe472a1febc38888133df6149cfedNAKAMURA Takumi 36969a46a948414734f5bc01994e54d88d153cb3fbChris Lattner#if defined(HAVE_UNISTD_H) 37969a46a948414734f5bc01994e54d88d153cb3fbChris Lattner# include <unistd.h> 38969a46a948414734f5bc01994e54d88d153cb3fbChris Lattner#endif 39b0cfa6cab85ce19c8ecaf9cdd3e34a3593d0b001Daniel Dunbar#if defined(HAVE_SYS_UIO_H) && defined(HAVE_WRITEV) 40b0cfa6cab85ce19c8ecaf9cdd3e34a3593d0b001Daniel Dunbar# include <sys/uio.h> 41b0cfa6cab85ce19c8ecaf9cdd3e34a3593d0b001Daniel Dunbar#endif 42b68dc369e06f8d1666562a70bab6bc3f7d642989Argyrios Kyrtzidis 431b5de0e7ee9e604d041cda1af544e27971ebeb81NAKAMURA Takumi#if defined(__CYGWIN__) 441b5de0e7ee9e604d041cda1af544e27971ebeb81NAKAMURA Takumi#include <io.h> 451b5de0e7ee9e604d041cda1af544e27971ebeb81NAKAMURA Takumi#endif 461b5de0e7ee9e604d041cda1af544e27971ebeb81NAKAMURA Takumi 47b68dc369e06f8d1666562a70bab6bc3f7d642989Argyrios Kyrtzidis#if defined(_MSC_VER) 4860d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner#include <io.h> 49cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson#ifndef STDIN_FILENO 50cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson# define STDIN_FILENO 0 51cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson#endif 52cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson#ifndef STDOUT_FILENO 53cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson# define STDOUT_FILENO 1 54cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson#endif 55cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson#ifndef STDERR_FILENO 56cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson# define STDERR_FILENO 2 57cb3718832375a581c5ea23f15918f3ea447a446cOwen Anderson#endif 5860d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner#endif 5960d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 60de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#ifdef LLVM_ON_WIN32 61de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#include "Windows/WindowsSupport.h" 62de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#endif 63de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 64969a46a948414734f5bc01994e54d88d153cb3fbChris Lattnerusing namespace llvm; 65969a46a948414734f5bc01994e54d88d153cb3fbChris Lattner 66e87b2abe91fc44bb9875188d80e3a43a9dfc41ebDan Gohmanraw_ostream::~raw_ostream() { 679a31254d0e51cfe08bc0e0c63ea04780cbc776f4Dan Gohman // raw_ostream's subclasses should take care to flush the buffer 689a31254d0e51cfe08bc0e0c63ea04780cbc776f4Dan Gohman // in their destructors. 699a31254d0e51cfe08bc0e0c63ea04780cbc776f4Dan Gohman assert(OutBufCur == OutBufStart && 709a31254d0e51cfe08bc0e0c63ea04780cbc776f4Dan Gohman "raw_ostream destructor called with non-empty buffer!"); 719a31254d0e51cfe08bc0e0c63ea04780cbc776f4Dan Gohman 72906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar if (BufferMode == InternalBuffer) 73906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar delete [] OutBufStart; 74e87b2abe91fc44bb9875188d80e3a43a9dfc41ebDan Gohman} 75969a46a948414734f5bc01994e54d88d153cb3fbChris Lattner 7660d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// An out of line virtual method to provide a home for the class vtable. 7760d396262460f0613175e52c00be5e8bfb89d8fbChris Lattnervoid raw_ostream::handle() {} 7860d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 79cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattnersize_t raw_ostream::preferred_buffer_size() const { 80208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman // BUFSIZ is intended to be a reasonable default. 81208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman return BUFSIZ; 82208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman} 83208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman 84208ec0f32eed8874074bddf97cd04f60a772198dDan Gohmanvoid raw_ostream::SetBuffered() { 85208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman // Ask the subclass to determine an appropriate buffer size. 86d7be663d4f96df8b0008c2116eb5af1de47ce613Dan Gohman if (size_t Size = preferred_buffer_size()) 87d7be663d4f96df8b0008c2116eb5af1de47ce613Dan Gohman SetBufferSize(Size); 88d7be663d4f96df8b0008c2116eb5af1de47ce613Dan Gohman else 89d7be663d4f96df8b0008c2116eb5af1de47ce613Dan Gohman // It may return 0, meaning this stream should be unbuffered. 90d7be663d4f96df8b0008c2116eb5af1de47ce613Dan Gohman SetUnbuffered(); 91208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman} 92208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman 9316e02097d283159c240996185a8b20f4ea46ccfcDan Gohmanvoid raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size, 94b1b051ec97c4e3c02cea554e169cbb4f85bcb2deNick Lewycky BufferKind Mode) { 95dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(((Mode == Unbuffered && !BufferStart && Size == 0) || 96dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines (Mode != Unbuffered && BufferStart && Size != 0)) && 97c8213b782735c7916cbc996c8dcdf89f9593d354Daniel Dunbar "stream must be unbuffered or have at least one byte"); 98906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar // Make sure the current buffer is free of content (we can't flush here; the 99906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar // child buffer management logic will be in write_impl). 100906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!"); 101524dea4d4ca6ecafa18e1e011934a2129c770f4fDan Gohman 102906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar if (BufferMode == InternalBuffer) 103906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar delete [] OutBufStart; 104906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar OutBufStart = BufferStart; 105524dea4d4ca6ecafa18e1e011934a2129c770f4fDan Gohman OutBufEnd = OutBufStart+Size; 106524dea4d4ca6ecafa18e1e011934a2129c770f4fDan Gohman OutBufCur = OutBufStart; 107906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar BufferMode = Mode; 108425d08c654c7893782b1215f9b2715bc1d90bd07Daniel Dunbar 109425d08c654c7893782b1215f9b2715bc1d90bd07Daniel Dunbar assert(OutBufStart <= OutBufEnd && "Invalid size!"); 110524dea4d4ca6ecafa18e1e011934a2129c770f4fDan Gohman} 111524dea4d4ca6ecafa18e1e011934a2129c770f4fDan Gohman 11266b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Andersonraw_ostream &raw_ostream::operator<<(unsigned long N) { 11366b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson // Zero is a special case. 11466b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson if (N == 0) 11566b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson return *this << '0'; 11616e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 11766b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson char NumberBuffer[20]; 11866b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 11966b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson char *CurPtr = EndPtr; 12016e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 12166b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson while (N) { 12266b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson *--CurPtr = '0' + char(N % 10); 12366b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson N /= 10; 12466b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson } 12566b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson return write(CurPtr, EndPtr-CurPtr); 12666b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson} 12766b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson 12866b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Andersonraw_ostream &raw_ostream::operator<<(long N) { 12966b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson if (N < 0) { 130de75d7ffcd5ed315240cfe0c52a821cf66411edaDaniel Dunbar *this << '-'; 13190406e18b8590d9588a76b849937d643dd3dc8b5Eli Friedman // Avoid undefined behavior on LONG_MIN with a cast. 13290406e18b8590d9588a76b849937d643dd3dc8b5Eli Friedman N = -(unsigned long)N; 13366b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson } 13416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 13566b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson return this->operator<<(static_cast<unsigned long>(N)); 13666b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson} 13766b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson 13866b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Andersonraw_ostream &raw_ostream::operator<<(unsigned long long N) { 139ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar // Output using 32-bit div/mod when possible. 14078a3dd8fe141f98aaf8fbd92cfb7c97d4ddf19d6Daniel Dunbar if (N == static_cast<unsigned long>(N)) 14178a3dd8fe141f98aaf8fbd92cfb7c97d4ddf19d6Daniel Dunbar return this->operator<<(static_cast<unsigned long>(N)); 14278a3dd8fe141f98aaf8fbd92cfb7c97d4ddf19d6Daniel Dunbar 143ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar char NumberBuffer[20]; 144de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar char *EndPtr = std::end(NumberBuffer); 145ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar char *CurPtr = EndPtr; 14616e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 147ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar while (N) { 148ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar *--CurPtr = '0' + char(N % 10); 149ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar N /= 10; 150ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar } 151ecbd0bc478ff3c53a4c2c3cb15098ee24c8218cbDaniel Dunbar return write(CurPtr, EndPtr-CurPtr); 15266b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson} 15366b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson 15466b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Andersonraw_ostream &raw_ostream::operator<<(long long N) { 155e211cd83f088ad462815676bc08b437c123cabedChris Lattner if (N < 0) { 156de75d7ffcd5ed315240cfe0c52a821cf66411edaDaniel Dunbar *this << '-'; 157e211cd83f088ad462815676bc08b437c123cabedChris Lattner // Avoid undefined behavior on INT64_MIN with a cast. 158e211cd83f088ad462815676bc08b437c123cabedChris Lattner N = -(unsigned long long)N; 15966b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson } 16016e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 16166b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson return this->operator<<(static_cast<unsigned long long>(N)); 16266b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson} 16366b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson 16448018e08f0d47331e72e5dcfcde2173217091b0eDaniel Dunbarraw_ostream &raw_ostream::write_hex(unsigned long long N) { 165b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar // Zero is a special case. 166b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar if (N == 0) 167b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar return *this << '0'; 168b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar 169de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar char NumberBuffer[16]; 170de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar char *EndPtr = std::end(NumberBuffer); 171b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar char *CurPtr = EndPtr; 172b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar 173b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar while (N) { 174de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned char x = static_cast<unsigned char>(N) % 16; 175de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar *--CurPtr = hexdigit(x, /*LowerCase*/true); 176b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar N /= 16; 177b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar } 178b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar 179b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar return write(CurPtr, EndPtr-CurPtr); 180944fac71e082cc2664cc71b4d3f6c72bab7143fbChris Lattner} 181944fac71e082cc2664cc71b4d3f6c72bab7143fbChris Lattner 18210a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbarraw_ostream &raw_ostream::write_escaped(StringRef Str, 18310a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar bool UseHexEscapes) { 184de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (unsigned char c : Str) { 185522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar switch (c) { 186522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar case '\\': 187522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar *this << '\\' << '\\'; 188522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar break; 189522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar case '\t': 190522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar *this << '\\' << 't'; 191522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar break; 192522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar case '\n': 193522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar *this << '\\' << 'n'; 194522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar break; 195522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar case '"': 196522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar *this << '\\' << '"'; 197522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar break; 198522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar default: 199522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar if (std::isprint(c)) { 200522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar *this << c; 201522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar break; 202522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar } 203522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar 20410a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar // Write out the escaped representation. 20510a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar if (UseHexEscapes) { 20610a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar *this << '\\' << 'x'; 20710a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar *this << hexdigit((c >> 4 & 0xF)); 20810a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar *this << hexdigit((c >> 0) & 0xF); 20910a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar } else { 21010a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar // Always use a full 3-character octal escape. 21110a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar *this << '\\'; 21210a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar *this << char('0' + ((c >> 6) & 7)); 21310a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar *this << char('0' + ((c >> 3) & 7)); 21410a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar *this << char('0' + ((c >> 0) & 7)); 21510a049e6cf50eb9a1dddae49dc21513cfeddcb47Daniel Dunbar } 216522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar } 217522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar } 218522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar 219522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar return *this; 220522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar} 221522b113a752a8e86932eebdc41ba07e058950e41Daniel Dunbar 22248018e08f0d47331e72e5dcfcde2173217091b0eDaniel Dunbarraw_ostream &raw_ostream::operator<<(const void *P) { 22348018e08f0d47331e72e5dcfcde2173217091b0eDaniel Dunbar *this << '0' << 'x'; 22448018e08f0d47331e72e5dcfcde2173217091b0eDaniel Dunbar 22548018e08f0d47331e72e5dcfcde2173217091b0eDaniel Dunbar return write_hex((uintptr_t) P); 22648018e08f0d47331e72e5dcfcde2173217091b0eDaniel Dunbar} 22748018e08f0d47331e72e5dcfcde2173217091b0eDaniel Dunbar 22823132b188ba651ba172380cd082cc286df73d440Chris Lattnerraw_ostream &raw_ostream::operator<<(double N) { 229d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi#ifdef _WIN32 230d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi // On MSVCRT and compatible, output of %e is incompatible to Posix 231d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi // by default. Number of exponent digits should be at least 2. "%+03d" 232d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi // FIXME: Implement our formatter to here or Support/Format.h! 233de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#if defined(__MINGW32__) 23436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // FIXME: It should be generic to C++11. 23536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (N == 0.0 && std::signbit(N)) 23636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return *this << "-0.000000e+00"; 23736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#else 238d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi int fpcl = _fpclass(N); 239d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi 240d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi // negative zero 241d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi if (fpcl == _FPCLASS_NZ) 242d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi return *this << "-0.000000e+00"; 24336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#endif 244d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi 245d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi char buf[16]; 246d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi unsigned len; 247ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines len = format("%e", N).snprint(buf, sizeof(buf)); 248d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi if (len <= sizeof(buf) - 2) { 249d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') { 250d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi int cs = buf[len - 4]; 251d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi if (cs == '+' || cs == '-') { 252d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi int c1 = buf[len - 2]; 253d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi int c0 = buf[len - 1]; 25487d0b9ed1462705dd9bf1cb7f67d0bf03af776c8Guy Benyei if (isdigit(static_cast<unsigned char>(c1)) && 25587d0b9ed1462705dd9bf1cb7f67d0bf03af776c8Guy Benyei isdigit(static_cast<unsigned char>(c0))) { 256d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi // Trim leading '0': "...e+012" -> "...e+12\0" 257d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi buf[len - 3] = c1; 258d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi buf[len - 2] = c0; 259d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi buf[--len] = 0; 260d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi } 261d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi } 262d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi } 263d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi return this->operator<<(buf); 264d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi } 265d4f4e6ee2c1eb80b8a1d3199e7747405fee956a3NAKAMURA Takumi#endif 266f304ff63d334d80da82383e67963c0f1f73f67edBenjamin Kramer return this->operator<<(format("%e", N)); 26723132b188ba651ba172380cd082cc286df73d440Chris Lattner} 26823132b188ba651ba172380cd082cc286df73d440Chris Lattner 26923132b188ba651ba172380cd082cc286df73d440Chris Lattner 27023132b188ba651ba172380cd082cc286df73d440Chris Lattner 271cf2a2c6a26427733f31dd539c6ee6486ea191da2Daniel Dunbarvoid raw_ostream::flush_nonempty() { 272cf2a2c6a26427733f31dd539c6ee6486ea191da2Daniel Dunbar assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty."); 273906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar size_t Length = OutBufCur - OutBufStart; 274906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar OutBufCur = OutBufStart; 275906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar write_impl(OutBufStart, Length); 276cf2a2c6a26427733f31dd539c6ee6486ea191da2Daniel Dunbar} 277cf2a2c6a26427733f31dd539c6ee6486ea191da2Daniel Dunbar 278de75d7ffcd5ed315240cfe0c52a821cf66411edaDaniel Dunbarraw_ostream &raw_ostream::write(unsigned char C) { 279262541b074e6bbb83200ab3ce4f95ab8ab075013Daniel Dunbar // Group exceptional cases into a single branch. 28055907d1274ce715b92d584e305e0708e333a33c0Benjamin Kramer if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) { 28155907d1274ce715b92d584e305e0708e333a33c0Benjamin Kramer if (LLVM_UNLIKELY(!OutBufStart)) { 282906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar if (BufferMode == Unbuffered) { 2833731604f1f73cb29a9554660b27aecba1c5c032bDan Gohman write_impl(reinterpret_cast<char*>(&C), 1); 2843731604f1f73cb29a9554660b27aecba1c5c032bDan Gohman return *this; 2853731604f1f73cb29a9554660b27aecba1c5c032bDan Gohman } 286ecc67e2e1b2c13c99427510fff71d598086eb309Daniel Dunbar // Set up a buffer and start over. 287ecc67e2e1b2c13c99427510fff71d598086eb309Daniel Dunbar SetBuffered(); 288ecc67e2e1b2c13c99427510fff71d598086eb309Daniel Dunbar return write(C); 2893731604f1f73cb29a9554660b27aecba1c5c032bDan Gohman } 290ecc67e2e1b2c13c99427510fff71d598086eb309Daniel Dunbar 291ecc67e2e1b2c13c99427510fff71d598086eb309Daniel Dunbar flush_nonempty(); 292d17d74bb80d9da1712a066df40122e8584dad227Daniel Dunbar } 293d17d74bb80d9da1712a066df40122e8584dad227Daniel Dunbar 294de75d7ffcd5ed315240cfe0c52a821cf66411edaDaniel Dunbar *OutBufCur++ = C; 295b451a0cdec5a24965d122bb749671db9084b92eeDaniel Dunbar return *this; 296de75d7ffcd5ed315240cfe0c52a821cf66411edaDaniel Dunbar} 297944fac71e082cc2664cc71b4d3f6c72bab7143fbChris Lattner 298ad60f660c6fd1999a3e21823128d37aca62e9285Dan Gohmanraw_ostream &raw_ostream::write(const char *Ptr, size_t Size) { 299262541b074e6bbb83200ab3ce4f95ab8ab075013Daniel Dunbar // Group exceptional cases into a single branch. 30055907d1274ce715b92d584e305e0708e333a33c0Benjamin Kramer if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) { 30155907d1274ce715b92d584e305e0708e333a33c0Benjamin Kramer if (LLVM_UNLIKELY(!OutBufStart)) { 302906d5b4455c6d605ab62f26d45cad2e49bf948bbDaniel Dunbar if (BufferMode == Unbuffered) { 30333e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman write_impl(Ptr, Size); 30433e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman return *this; 30533e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman } 30633e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman // Set up a buffer and start over. 307208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman SetBuffered(); 30833e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman return write(Ptr, Size); 30933e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman } 310ecc67e2e1b2c13c99427510fff71d598086eb309Daniel Dunbar 311ca9714470ec51ec52833eee46bca0062d92e92f3Benjamin Kramer size_t NumBytes = OutBufEnd - OutBufCur; 312ca9714470ec51ec52833eee46bca0062d92e92f3Benjamin Kramer 313e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer // If the buffer is empty at this point we have a string that is larger 314ca9714470ec51ec52833eee46bca0062d92e92f3Benjamin Kramer // than the buffer. Directly write the chunk that is a multiple of the 315ca9714470ec51ec52833eee46bca0062d92e92f3Benjamin Kramer // preferred buffer size and put the remainder in the buffer. 31655907d1274ce715b92d584e305e0708e333a33c0Benjamin Kramer if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) { 317ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(NumBytes != 0 && "undefined behavior"); 318ca9714470ec51ec52833eee46bca0062d92e92f3Benjamin Kramer size_t BytesToWrite = Size - (Size % NumBytes); 319ca9714470ec51ec52833eee46bca0062d92e92f3Benjamin Kramer write_impl(Ptr, BytesToWrite); 320b79d25ca9c3b895d8fdc88c3acefec1202ca9da3Matt Beaumont-Gay size_t BytesRemaining = Size - BytesToWrite; 321b79d25ca9c3b895d8fdc88c3acefec1202ca9da3Matt Beaumont-Gay if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) { 322b79d25ca9c3b895d8fdc88c3acefec1202ca9da3Matt Beaumont-Gay // Too much left over to copy into our buffer. 323b79d25ca9c3b895d8fdc88c3acefec1202ca9da3Matt Beaumont-Gay return write(Ptr + BytesToWrite, BytesRemaining); 324b79d25ca9c3b895d8fdc88c3acefec1202ca9da3Matt Beaumont-Gay } 325b79d25ca9c3b895d8fdc88c3acefec1202ca9da3Matt Beaumont-Gay copy_to_buffer(Ptr + BytesToWrite, BytesRemaining); 326e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer return *this; 327e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer } 328e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer 329e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer // We don't have enough space in the buffer to fit the string in. Insert as 330e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer // much as possible, flush and start over with the remainder. 331e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer copy_to_buffer(Ptr, NumBytes); 332e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer flush_nonempty(); 333e90756d8a095264f6d6ae6b3a660e73c587162cdBenjamin Kramer return write(Ptr + NumBytes, Size - NumBytes); 334262541b074e6bbb83200ab3ce4f95ab8ab075013Daniel Dunbar } 33533e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman 33633e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman copy_to_buffer(Ptr, Size); 33733e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman 33833e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman return *this; 33933e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman} 34033e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman 34133e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohmanvoid raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) { 342c6126e8f7eca8e6f089fdb0cb22c27d6e05d4a1fDan Gohman assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!"); 3434e8e642eaa969db43b2a3ff6955abf3ca8b6789aDan Gohman 34466b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson // Handle short strings specially, memcpy isn't very good at very short 34566b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson // strings. 34666b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson switch (Size) { 34766b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH 34866b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH 34966b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH 35066b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH 35166b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson case 0: break; 35266b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson default: 35333e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman memcpy(OutBufCur, Ptr, Size); 35466b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson break; 35566b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson } 356e77e434bc96f2935dcf337909c4009324fe24eafDaniel Dunbar 35733e49ef5e5dc2d3e65bcd4fc1f20874bf3847829Dan Gohman OutBufCur += Size; 35866b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson} 35966b17ba0d263442b8b4e82aaa08acc0df85e1787Owen Anderson 360097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner// Formatted output. 361097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattnerraw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) { 362262541b074e6bbb83200ab3ce4f95ab8ab075013Daniel Dunbar // If we have more than a few bytes left in our output buffer, try 363262541b074e6bbb83200ab3ce4f95ab8ab075013Daniel Dunbar // formatting directly onto its end. 364ad60f660c6fd1999a3e21823128d37aca62e9285Dan Gohman size_t NextBufferSize = 127; 3659441cfe4880018a85af9710ad405d4f2e522acc2Daniel Dunbar size_t BufferBytesLeft = OutBufEnd - OutBufCur; 3669441cfe4880018a85af9710ad405d4f2e522acc2Daniel Dunbar if (BufferBytesLeft > 3) { 367ad60f660c6fd1999a3e21823128d37aca62e9285Dan Gohman size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft); 36816e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 369097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // Common case is that we have plenty of space. 3709441cfe4880018a85af9710ad405d4f2e522acc2Daniel Dunbar if (BytesUsed <= BufferBytesLeft) { 371097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner OutBufCur += BytesUsed; 372097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner return *this; 373097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner } 37416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 375097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // Otherwise, we overflowed and the return value tells us the size to try 376097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // again with. 377097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner NextBufferSize = BytesUsed; 378097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner } 37916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 380097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // If we got here, we didn't have enough space in the output buffer for the 381097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // string. Try printing into a SmallVector that is resized to have enough 382097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // space. Iterate until we win. 383097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner SmallVector<char, 128> V; 38416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 385097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner while (1) { 386097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner V.resize(NextBufferSize); 38716e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 388097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // Try formatting into the SmallVector. 3899441cfe4880018a85af9710ad405d4f2e522acc2Daniel Dunbar size_t BytesUsed = Fmt.print(V.data(), NextBufferSize); 39016e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 391097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // If BytesUsed fit into the vector, we win. 392f61ca1eeda9cf2427047d83febe6fac1fbb1e84eChris Lattner if (BytesUsed <= NextBufferSize) 3939441cfe4880018a85af9710ad405d4f2e522acc2Daniel Dunbar return write(V.data(), BytesUsed); 39416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 395097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner // Otherwise, try again with a new size. 396097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?"); 397097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner NextBufferSize = BytesUsed; 398097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner } 399097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner} 400097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner 40137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesraw_ostream &raw_ostream::operator<<(const FormattedString &FS) { 40237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned Len = FS.Str.size(); 40337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines int PadAmount = FS.Width - Len; 40437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (FS.RightJustify && (PadAmount > 0)) 40537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines this->indent(PadAmount); 40637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines this->operator<<(FS.Str); 40737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!FS.RightJustify && (PadAmount > 0)) 40837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines this->indent(PadAmount); 40937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return *this; 41037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} 41137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 41237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesraw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) { 41337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (FN.Hex) { 41437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned Nibbles = (64 - countLeadingZeros(FN.HexValue)+3)/4; 415ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned PrefixChars = FN.HexPrefix ? 2 : 0; 416ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned Width = std::max(FN.Width, Nibbles + PrefixChars); 417ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 41837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines char NumberBuffer[20] = "0x0000000000000000"; 419ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!FN.HexPrefix) 420ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines NumberBuffer[1] = '0'; 42137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines char *EndPtr = NumberBuffer+Width; 42237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines char *CurPtr = EndPtr; 42337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned long long N = FN.HexValue; 42437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines while (N) { 425de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned char x = static_cast<unsigned char>(N) % 16; 426de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar *--CurPtr = hexdigit(x, !FN.Upper); 42737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines N /= 16; 42837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 42937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 43037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return write(NumberBuffer, Width); 43137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } else { 43237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // Zero is a special case. 43337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (FN.DecValue == 0) { 43437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines this->indent(FN.Width-1); 43537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return *this << '0'; 43637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 43737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines char NumberBuffer[32]; 43837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines char *EndPtr = NumberBuffer+sizeof(NumberBuffer); 43937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines char *CurPtr = EndPtr; 44037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool Neg = (FN.DecValue < 0); 44137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines uint64_t N = Neg ? -static_cast<uint64_t>(FN.DecValue) : FN.DecValue; 44237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines while (N) { 44337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines *--CurPtr = '0' + char(N % 10); 44437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines N /= 10; 44537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 44637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines int Len = EndPtr - CurPtr; 44737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines int Pad = FN.Width - Len; 44837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Neg) 44937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines --Pad; 45037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pad > 0) 45137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines this->indent(Pad); 45237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Neg) 45337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines *this << '-'; 45437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return write(CurPtr, Len); 45537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 45637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} 45737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 45837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 459c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner/// indent - Insert 'NumSpaces' spaces. 460c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattnerraw_ostream &raw_ostream::indent(unsigned NumSpaces) { 46161ee100b97adda5dcf1c02df030e5776bb374a5aDan Gohman static const char Spaces[] = " " 46261ee100b97adda5dcf1c02df030e5776bb374a5aDan Gohman " " 46361ee100b97adda5dcf1c02df030e5776bb374a5aDan Gohman " "; 464c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner 465c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner // Usually the indentation is small, handle it with a fastpath. 466cb1308b74a64cea97fef532840452b38864bbff6Dan Gohman if (NumSpaces < array_lengthof(Spaces)) 467c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner return write(Spaces, NumSpaces); 46816e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 469c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner while (NumSpaces) { 470cb1308b74a64cea97fef532840452b38864bbff6Dan Gohman unsigned NumToWrite = std::min(NumSpaces, 471cb1308b74a64cea97fef532840452b38864bbff6Dan Gohman (unsigned)array_lengthof(Spaces)-1); 472c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner write(Spaces, NumToWrite); 473c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner NumSpaces -= NumToWrite; 474c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner } 475c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner return *this; 476c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner} 477c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner 478c5a227ddd1fa09cd66e4fd1c0473be5c2b4f8f32Chris Lattner 479097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner//===----------------------------------------------------------------------===// 480097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner// Formatted Output 481097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner//===----------------------------------------------------------------------===// 482097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner 483097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner// Out of line virtual method. 484097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattnervoid format_object_base::home() { 485097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner} 486097af7fc8f8688cc21453a5561347f14ca7c5771Chris Lattner 48760d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner//===----------------------------------------------------------------------===// 48860d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner// raw_fd_ostream 48960d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner//===----------------------------------------------------------------------===// 49060d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 4910c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainarstatic int getFD(StringRef Filename, std::error_code &EC, 4920c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar sys::fs::OpenFlags Flags) { 4932499990699899e6da865c919fe63ef6e6c6f4a00Dan Gohman // Handle "-" as stdout. Note that when we do this, we consider ourself 4942499990699899e6da865c919fe63ef6e6c6f4a00Dan Gohman // the owner of stdout. This means that we can do things like close the 4952499990699899e6da865c919fe63ef6e6c6f4a00Dan Gohman // file descriptor when we're done and set the "binary" flag globally. 49637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Filename == "-") { 4970c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar EC = std::error_code(); 4980d9eb9b4917340acbfc831890655b8e9724959f6Daniel Dunbar // If user requested binary then put stdout into binary mode if 4990d9eb9b4917340acbfc831890655b8e9724959f6Daniel Dunbar // possible. 50036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!(Flags & sys::fs::F_Text)) 5019f1d9fd1964d82f3e801efb71518144492cdf290Rafael Espindola sys::ChangeStdoutToBinary(); 5020c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar return STDOUT_FILENO; 503c52b128e1a9b1f16403dcbabf46ffc8ee1f7082eChris Lattner } 50416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 5050c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar int FD; 50637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines EC = sys::fs::openFileForWrite(Filename, FD, Flags); 5070c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar if (EC) 5080c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar return -1; 50916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 5100c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar return FD; 51160d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner} 51260d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 5130c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainarraw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC, 5140c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar sys::fs::OpenFlags Flags) 5150c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar : raw_fd_ostream(getFD(Filename, EC, Flags), true) {} 5160c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar 5170c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar/// FD is the file descriptor that this writes to. If ShouldClose is true, this 5180c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar/// closes the file when the stream is destroyed. 519a872a0f5f800b352ab9af9d0f1e975ea0dead4efFrancois Pichetraw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered) 5200c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose), 521f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Error(false) { 5220c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar if (FD < 0 ) { 5230c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar ShouldClose = false; 5240c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar return; 5250c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar } 5262634a5425c29eca79f2cc2e309274d365697d0a7Michael J. Spencer 5272634a5425c29eca79f2cc2e309274d365697d0a7Michael J. Spencer // Get the starting position. 5282634a5425c29eca79f2cc2e309274d365697d0a7Michael J. Spencer off_t loc = ::lseek(FD, 0, SEEK_CUR); 5290c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar#ifdef LLVM_ON_WIN32 5300c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes. 5310c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar sys::fs::file_status Status; 5320c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar std::error_code EC = status(FD, Status); 5330c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar SupportsSeeking = !EC && Status.type() == sys::fs::file_type::regular_file; 5340c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar#else 5350c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar SupportsSeeking = loc != (off_t)-1; 5360c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar#endif 5370c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar if (!SupportsSeeking) 5382634a5425c29eca79f2cc2e309274d365697d0a7Michael J. Spencer pos = 0; 5392634a5425c29eca79f2cc2e309274d365697d0a7Michael J. Spencer else 5402634a5425c29eca79f2cc2e309274d365697d0a7Michael J. Spencer pos = static_cast<uint64_t>(loc); 541a872a0f5f800b352ab9af9d0f1e975ea0dead4efFrancois Pichet} 542a872a0f5f800b352ab9af9d0f1e975ea0dead4efFrancois Pichet 54360d396262460f0613175e52c00be5e8bfb89d8fbChris Lattnerraw_fd_ostream::~raw_fd_ostream() { 5448df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman if (FD >= 0) { 5458df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman flush(); 54637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (ShouldClose && sys::Process::SafelyCloseFileDescriptor(FD)) 54737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines error_detected(); 5488df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman } 5498df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman 5507a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi#ifdef __MINGW32__ 5517a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi // On mingw, global dtors should not call exit(). 5527a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi // report_fatal_error() invokes exit(). We know report_fatal_error() 5537a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi // might not write messages to stderr when any errors were detected 5547a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi // on FD == 2. 5557a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi if (FD == 2) return; 5567a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi#endif 5577a7215b563ad03d499742612d7d595b9299664b7NAKAMURA Takumi 5588df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman // If there are any pending errors, report them now. Clients wishing 5598df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman // to avoid report_fatal_error calls should check for errors with 5608df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman // has_error() and clear the error flag with clear_error() before 5618df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman // destructing raw_ostream objects which may have errors. 5628df0e010469db2db5c641a50d9cfa74a5ffe68eaDan Gohman if (has_error()) 5632b7f2190514244cedc6b74aea42c2f9a3ee714a9Chad Rosier report_fatal_error("IO failure on output stream.", /*GenCrashDiag=*/false); 56493d81b697c054c04d1995af0393f20ce23f520d4Chris Lattner} 56517e9edc4a7bbeadf756494cf39fcacc9eff72202Chris Lattner 566d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohman 567ad60f660c6fd1999a3e21823128d37aca62e9285Dan Gohmanvoid raw_fd_ostream::write_impl(const char *Ptr, size_t Size) { 56816e02097d283159c240996185a8b20f4ea46ccfcDan Gohman assert(FD >= 0 && "File already closed."); 56989a66a96fed75796bc5e079217130b62105cb438Daniel Dunbar pos += Size; 5705fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman 571de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#ifndef LLVM_ON_WIN32 572de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool ShouldWriteInChunks = false; 573de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#else 574de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Writing a large size of output to Windows console returns ENOMEM. It seems 575de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // that, prior to Windows 8, WriteFile() is redirecting to WriteConsole(), and 576de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // the latter has a size limit (66000 bytes or less, depending on heap usage). 577de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool ShouldWriteInChunks = !!::_isatty(FD) && !RunningWindows8OrGreater(); 578de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#endif 579de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 58066760be9195d0f19efc462c080e6d123e862d641Benjamin Kramer do { 581de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar size_t ChunkSize = Size; 582de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (ChunkSize > 32767 && ShouldWriteInChunks) 583de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ChunkSize = 32767; 584de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 585de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ssize_t ret = ::write(FD, Ptr, ChunkSize); 5865fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman 5875fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman if (ret < 0) { 5885fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman // If it's a recoverable error, swallow it and retry the write. 58968e947ac61dd6f3404ea3fbc3b5f0c539c694a06Dan Gohman // 59068e947ac61dd6f3404ea3fbc3b5f0c539c694a06Dan Gohman // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since 59168e947ac61dd6f3404ea3fbc3b5f0c539c694a06Dan Gohman // raw_ostream isn't designed to do non-blocking I/O. However, some 59268e947ac61dd6f3404ea3fbc3b5f0c539c694a06Dan Gohman // programs, such as old versions of bjam, have mistakenly used 59368e947ac61dd6f3404ea3fbc3b5f0c539c694a06Dan Gohman // O_NONBLOCK. For compatibility, emulate blocking semantics by 59468e947ac61dd6f3404ea3fbc3b5f0c539c694a06Dan Gohman // spinning until the write succeeds. If you don't want spinning, 59568e947ac61dd6f3404ea3fbc3b5f0c539c694a06Dan Gohman // don't use O_NONBLOCK file descriptors with raw_ostream. 59606572793a7ae8b45ad802c04ab508a36b915d999Dan Gohman if (errno == EINTR || errno == EAGAIN 59706572793a7ae8b45ad802c04ab508a36b915d999Dan Gohman#ifdef EWOULDBLOCK 59806572793a7ae8b45ad802c04ab508a36b915d999Dan Gohman || errno == EWOULDBLOCK 59906572793a7ae8b45ad802c04ab508a36b915d999Dan Gohman#endif 60006572793a7ae8b45ad802c04ab508a36b915d999Dan Gohman ) 6015fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman continue; 6025fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman 6035fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman // Otherwise it's a non-recoverable error. Note it and quit. 6045fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman error_detected(); 6055fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman break; 6065fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman } 6075fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman 6085fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman // The write may have written some or all of the data. Update the 6095fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman // size and buffer pointer to reflect the remainder that needs 6105fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman // to be written. If there are no bytes left, we're done. 6115fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman Ptr += ret; 6125fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman Size -= ret; 6135fe89d0126ec215ac2a09884bfbd4dd7bf8e7d2fDan Gohman } while (Size > 0); 61460d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner} 61560d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 616d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohmanvoid raw_fd_ostream::close() { 617d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohman assert(ShouldClose); 618d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohman ShouldClose = false; 619d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohman flush(); 62037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (sys::Process::SafelyCloseFileDescriptor(FD)) 62137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines error_detected(); 622d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohman FD = -1; 623d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohman} 624d2da32711d8780a20df4554d41754bd0bc7fa35fDan Gohman 6259c27886dd5d504f2b03c6fcb57aba23e5e44c4faTed Kremenekuint64_t raw_fd_ostream::seek(uint64_t off) { 626de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar assert(SupportsSeeking && "Stream does not support seeking!"); 6279c27886dd5d504f2b03c6fcb57aba23e5e44c4faTed Kremenek flush(); 628579fb87ce7c7a407b76fb47da17b605d44db2d17Daniel Dunbar pos = ::lseek(FD, off, SEEK_SET); 6290c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar if (pos == (uint64_t)-1) 630e87b2abe91fc44bb9875188d80e3a43a9dfc41ebDan Gohman error_detected(); 63116e02097d283159c240996185a8b20f4ea46ccfcDan Gohman return pos; 6329c27886dd5d504f2b03c6fcb57aba23e5e44c4faTed Kremenek} 6339c27886dd5d504f2b03c6fcb57aba23e5e44c4faTed Kremenek 6346948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainarvoid raw_fd_ostream::pwrite_impl(const char *Ptr, size_t Size, 6356948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar uint64_t Offset) { 6360c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar uint64_t Pos = tell(); 6370c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar seek(Offset); 6380c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar write(Ptr, Size); 6390c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar seek(Pos); 6400c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar} 6410c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar 642cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattnersize_t raw_fd_ostream::preferred_buffer_size() const { 64329269d03af6dc3feb69d0230831a059f39c03700Chris Lattner#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix) 64421aa347c2816aa8fc635ad05c5ab786234b32c7eChris Lattner // Windows and Minix have no st_blksize. 645208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman assert(FD >= 0 && "File not yet open!"); 646208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman struct stat statbuf; 647cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner if (fstat(FD, &statbuf) != 0) 648cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner return 0; 64916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman 650cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner // If this is a terminal, don't use buffering. Line buffering 651cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner // would be a more traditional thing to do, but it's not worth 652cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner // the complexity. 653cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner if (S_ISCHR(statbuf.st_mode) && isatty(FD)) 654cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner return 0; 655cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner // Return the preferred block size. 656cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattner return statbuf.st_blksize; 6579ba7f657432f6be61620439b4b284dd7b9f7c353Dan Gohman#else 658208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman return raw_ostream::preferred_buffer_size(); 6599ba7f657432f6be61620439b4b284dd7b9f7c353Dan Gohman#endif 660208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman} 661208ec0f32eed8874074bddf97cd04f60a772198dDan Gohman 662e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwinraw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold, 663e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin bool bg) { 664e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin if (sys::Process::ColorNeedsFlush()) 665e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin flush(); 666e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin const char *colorcode = 667e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg) 668e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin : sys::Process::OutputColor(colors, bold, bg); 669e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin if (colorcode) { 670ad60f660c6fd1999a3e21823128d37aca62e9285Dan Gohman size_t len = strlen(colorcode); 671e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin write(colorcode, len); 672e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin // don't account colors towards output characters 673e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin pos -= len; 674e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin } 675e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin return *this; 676e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin} 677e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin 678e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwinraw_ostream &raw_fd_ostream::resetColor() { 679e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin if (sys::Process::ColorNeedsFlush()) 680e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin flush(); 681e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin const char *colorcode = sys::Process::ResetColor(); 682e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin if (colorcode) { 683ad60f660c6fd1999a3e21823128d37aca62e9285Dan Gohman size_t len = strlen(colorcode); 684e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin write(colorcode, len); 685e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin // don't account colors towards output characters 686e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin pos -= len; 687e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin } 688e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin return *this; 689e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin} 690e8ebb0fe1bba0fdff7475d98e1f8a04804b0b056Torok Edwin 691246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramerraw_ostream &raw_fd_ostream::reverseColor() { 692246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer if (sys::Process::ColorNeedsFlush()) 693246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer flush(); 694246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer const char *colorcode = sys::Process::OutputReverse(); 695246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer if (colorcode) { 696246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer size_t len = strlen(colorcode); 697246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer write(colorcode, len); 698246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer // don't account colors towards output characters 699246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer pos -= len; 700246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer } 701246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer return *this; 702246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer} 703246de858e37a989a9cdf9b80d7434453b2c52e70Benjamin Kramer 704ec080467f5b322441055de1f6cd4f08edc23d7dfDan Gohmanbool raw_fd_ostream::is_displayed() const { 705ec080467f5b322441055de1f6cd4f08edc23d7dfDan Gohman return sys::Process::FileDescriptorIsDisplayed(FD); 706ec080467f5b322441055de1f6cd4f08edc23d7dfDan Gohman} 707ec080467f5b322441055de1f6cd4f08edc23d7dfDan Gohman 708d79637b940dfbcdc0b7c702d9655491ecca9d93dDaniel Dunbarbool raw_fd_ostream::has_colors() const { 709d79637b940dfbcdc0b7c702d9655491ecca9d93dDaniel Dunbar return sys::Process::FileDescriptorHasColors(FD); 710d79637b940dfbcdc0b7c702d9655491ecca9d93dDaniel Dunbar} 711d79637b940dfbcdc0b7c702d9655491ecca9d93dDaniel Dunbar 71207f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner//===----------------------------------------------------------------------===// 7135d56d9df928c48571980efe8d4205de8ab557b7cDan Gohman// outs(), errs(), nulls() 71407f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner//===----------------------------------------------------------------------===// 71560d396262460f0613175e52c00be5e8bfb89d8fbChris Lattner 71607f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner/// outs() - This returns a reference to a raw_ostream for standard output. 71707f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner/// Use it like: outs() << "foo" << "bar"; 718cb3718832375a581c5ea23f15918f3ea447a446cOwen Andersonraw_ostream &llvm::outs() { 719de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Set buffer settings to model stdout behavior. Delete the file descriptor 720de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // when the program exits, forcing error detection. This means that if you 721de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // ever call outs(), you can't open another raw_fd_ostream on stdout, as we'll 722de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // close stdout twice and print an error the second time. 7230c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar std::error_code EC; 7240c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar static raw_fd_ostream S("-", EC, sys::fs::F_None); 7250c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar assert(!EC); 72607f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner return S; 72707f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner} 72807f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner 72907f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner/// errs() - This returns a reference to a raw_ostream for standard error. 73007f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner/// Use it like: errs() << "foo" << "bar"; 731cb3718832375a581c5ea23f15918f3ea447a446cOwen Andersonraw_ostream &llvm::errs() { 732a1f89deb56eddf6a7738660063cbe7db9775b01cDan Gohman // Set standard error to be unbuffered by default. 733a1f89deb56eddf6a7738660063cbe7db9775b01cDan Gohman static raw_fd_ostream S(STDERR_FILENO, false, true); 73407f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner return S; 73507f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner} 73607f51f788e1dff2982ff0aae7c2ea3d00e48cc61Chris Lattner 73734ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar/// nulls() - This returns a reference to a raw_ostream which discards output. 73834ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbarraw_ostream &llvm::nulls() { 73934ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar static raw_null_ostream S; 74034ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar return S; 74134ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar} 74234ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar 7438f7be4731e979255c54eb8951b7a06ed4fd6ce45Douglas Gregor 74478a2812538d871a62d90f53ed66d26198876d011Chris Lattner//===----------------------------------------------------------------------===// 74578a2812538d871a62d90f53ed66d26198876d011Chris Lattner// raw_string_ostream 74678a2812538d871a62d90f53ed66d26198876d011Chris Lattner//===----------------------------------------------------------------------===// 74778a2812538d871a62d90f53ed66d26198876d011Chris Lattner 74835979c021e4789b915cd569145bd9fb9ae0d8d8bDaniel Dunbarraw_string_ostream::~raw_string_ostream() { 74935979c021e4789b915cd569145bd9fb9ae0d8d8bDaniel Dunbar flush(); 75035979c021e4789b915cd569145bd9fb9ae0d8d8bDaniel Dunbar} 75135979c021e4789b915cd569145bd9fb9ae0d8d8bDaniel Dunbar 752ad60f660c6fd1999a3e21823128d37aca62e9285Dan Gohmanvoid raw_string_ostream::write_impl(const char *Ptr, size_t Size) { 75389a66a96fed75796bc5e079217130b62105cb438Daniel Dunbar OS.append(Ptr, Size); 75478a2812538d871a62d90f53ed66d26198876d011Chris Lattner} 75578a2812538d871a62d90f53ed66d26198876d011Chris Lattner 75678a2812538d871a62d90f53ed66d26198876d011Chris Lattner//===----------------------------------------------------------------------===// 75778a2812538d871a62d90f53ed66d26198876d011Chris Lattner// raw_svector_ostream 75878a2812538d871a62d90f53ed66d26198876d011Chris Lattner//===----------------------------------------------------------------------===// 75978a2812538d871a62d90f53ed66d26198876d011Chris Lattner 760f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainaruint64_t raw_svector_ostream::current_pos() const { return OS.size(); } 7610c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar 762f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarvoid raw_svector_ostream::write_impl(const char *Ptr, size_t Size) { 763f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar OS.append(Ptr, Ptr + Size); 76435979c021e4789b915cd569145bd9fb9ae0d8d8bDaniel Dunbar} 76535979c021e4789b915cd569145bd9fb9ae0d8d8bDaniel Dunbar 7666948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainarvoid raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size, 7676948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar uint64_t Offset) { 768f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar memcpy(OS.data() + Offset, Ptr, Size); 769d14787e49777888eb7c685c0d5803044e7b7971aDaniel Dunbar} 770d14787e49777888eb7c685c0d5803044e7b7971aDaniel Dunbar 77134ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar//===----------------------------------------------------------------------===// 77234ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar// raw_null_ostream 77334ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar//===----------------------------------------------------------------------===// 77434ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar 775f78c835faa97a6f5c8021923c05f7514a550619fDan Gohmanraw_null_ostream::~raw_null_ostream() { 776f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman#ifndef NDEBUG 777f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman // ~raw_ostream asserts that the buffer is empty. This isn't necessary 778f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman // with raw_null_ostream, but it's better to have raw_null_ostream follow 779f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman // the rules than to change the rules just for raw_null_ostream. 780f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman flush(); 781f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman#endif 782f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman} 783f78c835faa97a6f5c8021923c05f7514a550619fDan Gohman 78434ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbarvoid raw_null_ostream::write_impl(const char *Ptr, size_t Size) { 78534ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar} 78634ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar 787cd0129f5a6f0485ecac525c17a3c5dff0a19ca5fChris Lattneruint64_t raw_null_ostream::current_pos() const { 78834ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar return 0; 78934ccf037fea3d83dcb18f72496775ec4c7dcd3d3Daniel Dunbar} 7900c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar 7916948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainarvoid raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size, 7926948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar uint64_t Offset) {} 793