Members/tobaru/cbc/CbC_llvm: lib/Support/raw

comparison lib/Support/raw_ostream.cpp @ 77:54457678186b

LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Mon, 08 Sep 2014 22:06:00 +0900
parents	95c75e76d11b
children	60c9769439b8

comparison

equal deleted inserted replaced

-:e874dbf0ad9d
+:54457678186b
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
-#include "llvm/Support/system_error.h"
 #include <cctype>
 #include <cerrno>
 #include <sys/stat.h>
+#include <system_error>
 // <fcntl.h> may provide O_BINARY.
 #if defined(HAVE_FCNTL_H)
 # include <fcntl.h>
 #endif
 SetUnbuffered();
 }
 void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
 BufferKind Mode) {
-assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) ||
+assert(((Mode == Unbuffered && !BufferStart && Size == 0) ||
-(Mode != Unbuffered && BufferStart && Size)) &&
+(Mode != Unbuffered && BufferStart && Size != 0)) &&
 "stream must be unbuffered or have at least one byte");
 // Make sure the current buffer is free of content (we can't flush here; the
 // child buffer management logic will be in write_impl).
 assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
 raw_ostream &raw_ostream::operator<<(double N) {
 #ifdef _WIN32
 // On MSVCRT and compatible, output of %e is incompatible to Posix
 // by default. Number of exponent digits should be at least 2. "%+03d"
 // FIXME: Implement our formatter to here or Support/Format.h!
+#if __cplusplus >= 201103L && defined(__MINGW32__)
+// FIXME: It should be generic to C++11.
+if (N == 0.0 && std::signbit(N))
+return *this << "-0.000000e+00";
+#else
 int fpcl = _fpclass(N);
 // negative zero
 if (fpcl == _FPCLASS_NZ)
 return *this << "-0.000000e+00";
+#endif
 char buf[16];
 unsigned len;
 len = snprintf(buf, sizeof(buf), "%e", N);
 if (len <= sizeof(buf) - 2) {
 //===----------------------------------------------------------------------===//
 //  raw_fd_ostream
 //===----------------------------------------------------------------------===//
-/// raw_fd_ostream - Open the specified file for writing. If an error
+raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
-/// occurs, information about the error is put into ErrorInfo, and the
-/// stream should be immediately destroyed; the string will be empty
-/// if no error occurred.
-raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo,
 sys::fs::OpenFlags Flags)
 : Error(false), UseAtomicWrites(false), pos(0) {
-assert(Filename != 0 && "Filename is null");
+EC = std::error_code();
-ErrorInfo.clear();
 // Handle "-" as stdout. Note that when we do this, we consider ourself
 // the owner of stdout. This means that we can do things like close the
 // file descriptor when we're done and set the "binary" flag globally.
-if (Filename[0] == '-' && Filename[1] == 0) {
+if (Filename == "-") {
 FD = STDOUT_FILENO;
 // If user requested binary then put stdout into binary mode if
 // possible.
-if (Flags & sys::fs::F_Binary)
+if (!(Flags & sys::fs::F_Text))
 sys::ChangeStdoutToBinary();
 // Close stdout when we're done, to detect any output errors.
 ShouldClose = true;
 return;
 }
-error_code EC = sys::fs::openFileForWrite(Filename, FD, Flags);
+EC = sys::fs::openFileForWrite(Filename, FD, Flags);
 if (EC) {
-ErrorInfo = "Error opening output file '" + std::string(Filename) + "': " +
-EC.message();
 ShouldClose = false;
 return;
 }
 // Ok, we successfully opened the file, so it'll need to be closed.
 /// ShouldClose is true, this closes the file when the stream is destroyed.
 raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
 : raw_ostream(unbuffered), FD(fd),
 ShouldClose(shouldClose), Error(false), UseAtomicWrites(false) {
 #ifdef O_BINARY
-// Setting STDOUT and STDERR to binary mode is necessary in Win32
+// Setting STDOUT to binary mode is necessary in Win32
 // to avoid undesirable linefeed conversion.
-if (fd == STDOUT_FILENO || fd == STDERR_FILENO)
+// Don't touch STDERR, or w*printf() (in assert()) would barf wide chars.
+if (fd == STDOUT_FILENO)
 setmode(fd, O_BINARY);
 #endif
 // Get the starting position.
 off_t loc = ::lseek(FD, 0, SEEK_CUR);
 /// outs() - This returns a reference to a raw_ostream for standard output.
 /// Use it like: outs() << "foo" << "bar";
 raw_ostream &llvm::outs() {
 // Set buffer settings to model stdout behavior.
-// Delete the file descriptor when the program exists, forcing error
+// Delete the file descriptor when the program exits, forcing error
 // detection. If you don't want this behavior, don't use outs().
 static raw_fd_ostream S(STDOUT_FILENO, true);
 return S;
 }
 OS.reserve(OS.capacity() * 2);
 SetBuffer(OS.end(), OS.capacity() - OS.size());
 }
 void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
-// If we're writing bytes from the end of the buffer into the smallvector, we
-// don't need to copy the bytes, just commit the bytes because they are
-// already in the right place.
 if (Ptr == OS.end()) {
-assert(OS.size() + Size <= OS.capacity() && "Invalid write_impl() call!");
+// Grow the buffer to include the scratch area without copying.
-OS.set_size(OS.size() + Size);
+size_t NewSize = OS.size() + Size;
+assert(NewSize <= OS.capacity() && "Invalid write_impl() call!");
+OS.set_size(NewSize);
 } else {
-assert(GetNumBytesInBuffer() == 0 &&
+assert(!GetNumBytesInBuffer());
-"Should be writing from buffer if some bytes in it");
+OS.append(Ptr, Ptr + Size);
-// Otherwise, do copy the bytes.
+}
-OS.append(Ptr, Ptr+Size);
-}
+OS.reserve(OS.size() + 64);
-// Grow the vector if necessary.
-if (OS.capacity() - OS.size() < 64)
-OS.reserve(OS.capacity() * 2);
-// Update the buffer position.
 SetBuffer(OS.end(), OS.capacity() - OS.size());
 }
 uint64_t raw_svector_ostream::current_pos() const {
 return OS.size();

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/Support/raw_ostream.cpp @ 77:54457678186b