// An out of line virtual method to provide a home for the class vtable.
void raw_ostream::handle() {}
-size_t raw_ostream::preferred_buffer_size() {
+size_t raw_ostream::preferred_buffer_size() const {
// BUFSIZ is intended to be a reasonable default.
return BUFSIZ;
}
void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
BufferKind Mode) {
assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) ||
- (Mode != Unbuffered && BufferStart && Size >= 64)) &&
- "stream must be unbuffered, or have >= 64 bytes of buffer");
+ (Mode != Unbuffered && BufferStart && Size)) &&
+ "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!");
return write(CurPtr, EndPtr-CurPtr);
}
+raw_ostream &raw_ostream::write_escaped(StringRef Str) {
+ for (unsigned i = 0, e = Str.size(); i != e; ++i) {
+ unsigned char c = Str[i];
+
+ switch (c) {
+ case '\\':
+ *this << '\\' << '\\';
+ break;
+ case '\t':
+ *this << '\\' << 't';
+ break;
+ case '\n':
+ *this << '\\' << 'n';
+ break;
+ case '"':
+ *this << '\\' << '"';
+ break;
+ default:
+ if (std::isprint(c)) {
+ *this << c;
+ break;
+ }
+
+ // Always expand to a 3-character octal escape.
+ *this << '\\';
+ *this << char('0' + ((c >> 6) & 7));
+ *this << char('0' + ((c >> 3) & 7));
+ *this << char('0' + ((c >> 0) & 7));
+ }
+ }
+
+ return *this;
+}
+
raw_ostream &raw_ostream::operator<<(const void *P) {
*this << '0' << 'x';
}
raw_ostream &raw_ostream::operator<<(double N) {
- this->operator<<(ftostr(N));
- return *this;
+ return this->operator<<(ftostr(N));
}
/// if no error occurred.
raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo,
unsigned Flags) : pos(0) {
- // Verify that we don't have both "append" and "force".
- assert((!(Flags & F_Force) || !(Flags & F_Append)) &&
- "Cannot specify both 'force' and 'append' file creation flags!");
+ // Verify that we don't have both "append" and "excl".
+ assert((!(Flags & F_Excl) || !(Flags & F_Append)) &&
+ "Cannot specify both 'excl' and 'append' file creation flags!");
ErrorInfo.clear();
OpenFlags |= O_BINARY;
#endif
- if (Flags & F_Force)
- OpenFlags |= O_TRUNC;
- else if (Flags & F_Append)
+ if (Flags & F_Append)
OpenFlags |= O_APPEND;
else
+ OpenFlags |= O_TRUNC;
+ if (Flags & F_Excl)
OpenFlags |= O_EXCL;
FD = open(Filename, OpenFlags, 0664);
return pos;
}
-size_t raw_fd_ostream::preferred_buffer_size() {
+size_t raw_fd_ostream::preferred_buffer_size() const {
#if !defined(_MSC_VER) && !defined(__MINGW32__) // Windows has no st_blksize.
assert(FD >= 0 && "File not yet open!");
struct stat statbuf;
- if (fstat(FD, &statbuf) == 0) {
- // If this is a terminal, don't use buffering. Line buffering
- // would be a more traditional thing to do, but it's not worth
- // the complexity.
- if (S_ISCHR(statbuf.st_mode) && isatty(FD))
- return 0;
- // Return the preferred block size.
- return statbuf.st_blksize;
- }
- error_detected();
+ if (fstat(FD, &statbuf) != 0)
+ return 0;
+
+ // If this is a terminal, don't use buffering. Line buffering
+ // would be a more traditional thing to do, but it's not worth
+ // the complexity.
+ if (S_ISCHR(statbuf.st_mode) && isatty(FD))
+ return 0;
+ // Return the preferred block size.
+ return statbuf.st_blksize;
#endif
return raw_ostream::preferred_buffer_size();
}
return *this;
}
+bool raw_fd_ostream::is_displayed() const {
+ return sys::Process::FileDescriptorIsDisplayed(FD);
+}
+
//===----------------------------------------------------------------------===//
// raw_stdout/err_ostream
//===----------------------------------------------------------------------===//
SetBuffer(OS.end(), OS.capacity() - OS.size());
}
-uint64_t raw_svector_ostream::current_pos() { return OS.size(); }
+uint64_t raw_svector_ostream::current_pos() const {
+ return OS.size();
+}
StringRef raw_svector_ostream::str() {
flush();
void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
}
-uint64_t raw_null_ostream::current_pos() {
+uint64_t raw_null_ostream::current_pos() const {
return 0;
}