ExternalBuffer
} BufferMode;
- /// Error This flag is true if an error of any kind has been detected.
- ///
- bool Error;
-
public:
// color order matches ANSI escape sequence, don't change
enum Colors {
};
explicit raw_ostream(bool unbuffered=false)
- : BufferMode(unbuffered ? Unbuffered : InternalBuffer), Error(false) {
+ : BufferMode(unbuffered ? Unbuffered : InternalBuffer) {
// Start out ready to flush.
OutBufStart = OutBufEnd = OutBufCur = 0;
}
virtual ~raw_ostream();
/// tell - Return the current offset with the file.
- uint64_t tell() { return current_pos() + GetNumBytesInBuffer(); }
-
- /// has_error - Return the value of the flag in this raw_ostream indicating
- /// whether an output error has been encountered.
- bool has_error() const {
- return Error;
- }
-
- /// clear_error - Set the flag read by has_error() to false. If the error
- /// flag is set at the time when this raw_ostream's destructor is called,
- /// llvm_report_error is called to report the error. Use clear_error()
- /// after handling the error to avoid this behavior.
- void clear_error() {
- Error = false;
- }
+ uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
//===--------------------------------------------------------------------===//
// Configuration Interface
SetBufferAndMode(new char[Size], Size, InternalBuffer);
}
- size_t GetBufferSize() {
+ size_t GetBufferSize() const {
// If we're supposed to be buffered but haven't actually gotten around
// to allocating the buffer yet, return the value that would be used.
if (BufferMode != Unbuffered && OutBufStart == 0)
// Inline fast path, particulary for constant strings where a sufficiently
// smart compiler will simplify strlen.
- this->operator<<(StringRef(Str));
- return *this;
+ return this->operator<<(StringRef(Str));
}
raw_ostream &operator<<(const std::string &Str) {
// Avoid the fast path, it would only increase code size for a marginal win.
- write(Str.data(), Str.length());
- return *this;
+ return write(Str.data(), Str.length());
}
raw_ostream &operator<<(unsigned long N);
raw_ostream &operator<<(long long N);
raw_ostream &operator<<(const void *P);
raw_ostream &operator<<(unsigned int N) {
- this->operator<<(static_cast<unsigned long>(N));
- return *this;
+ return this->operator<<(static_cast<unsigned long>(N));
}
raw_ostream &operator<<(int N) {
- this->operator<<(static_cast<long>(N));
- return *this;
+ return this->operator<<(static_cast<long>(N));
}
raw_ostream &operator<<(double N);
/// @param bold bold/brighter text, default false
/// @param bg if true change the background, default: change foreground
/// @returns itself so it can be used within << invocations
- virtual raw_ostream &changeColor(enum Colors, bool = false,
- bool = false) { return *this; }
+ virtual raw_ostream &changeColor(enum Colors, bool = false, bool = false) {
+ return *this; }
/// Resets the colors to terminal defaults. Call this when you are done
/// outputting colored text, or before program exit.
/// current_pos - Return the current position within the stream, not
/// counting the bytes currently in the buffer.
- virtual uint64_t current_pos() = 0;
+ virtual uint64_t current_pos() const = 0;
protected:
/// SetBuffer - Use the provided buffer as the raw_ostream buffer. This is
/// preferred_buffer_size - Return an efficient buffer size for the
/// underlying output mechanism.
- virtual size_t preferred_buffer_size();
-
- /// error_detected - Set the flag indicating that an output error has
- /// been encountered.
- void error_detected() { Error = true; }
+ virtual size_t preferred_buffer_size() const;
/// getBufferStart - Return the beginning of the current stream buffer, or 0
/// if the stream is unbuffered.
class raw_fd_ostream : public raw_ostream {
int FD;
bool ShouldClose;
+
+ /// Error This flag is true if an error of any kind has been detected.
+ ///
+ bool Error;
+
uint64_t pos;
/// write_impl - See raw_ostream::write_impl.
/// current_pos - Return the current position within the stream, not
/// counting the bytes currently in the buffer.
- virtual uint64_t current_pos() { return pos; }
+ virtual uint64_t current_pos() const { return pos; }
/// preferred_buffer_size - Determine an efficient buffer size.
- virtual size_t preferred_buffer_size();
+ virtual size_t preferred_buffer_size() const;
+
+ /// error_detected - Set the flag indicating that an output error has
+ /// been encountered.
+ void error_detected() { Error = true; }
public:
/// be immediately destroyed; the string will be empty if no error occurred.
/// This allows optional flags to control how the file will be opened.
///
- /// \param Filename - The file to open. If this is "-" then the
- /// stream will use stdout instead.
+ /// As a special case, if Filename is "-", then the stream will use
+ /// STDOUT_FILENO instead of opening a file. Note that it will still consider
+ /// itself to own the file descriptor. In particular, it will close the
+ /// file descriptor when it is done (this is necessary to detect
+ /// output errors).
raw_fd_ostream(const char *Filename, std::string &ErrorInfo,
unsigned Flags = 0);
/// ShouldClose is true, this closes the file when the stream is destroyed.
raw_fd_ostream(int fd, bool shouldClose,
bool unbuffered=false) : raw_ostream(unbuffered), FD(fd),
- ShouldClose(shouldClose) {}
+ ShouldClose(shouldClose),
+ Error(false) {}
~raw_fd_ostream();
/// close - Manually flush the stream and close the file.
+ /// Note that this does not call fsync.
void close();
/// seek - Flushes the stream and repositions the underlying file descriptor
- /// positition to the offset specified from the beginning of the file.
+ /// positition to the offset specified from the beginning of the file.
uint64_t seek(uint64_t off);
virtual raw_ostream &changeColor(enum Colors colors, bool bold=false,
virtual raw_ostream &resetColor();
virtual bool is_displayed() const;
+
+ /// has_error - Return the value of the flag in this raw_fd_ostream indicating
+ /// whether an output error has been encountered.
+ /// This doesn't implicitly flush any pending output. Also, it doesn't
+ /// guarantee to detect all errors unless the the stream has been closed.
+ bool has_error() const {
+ return Error;
+ }
+
+ /// clear_error - Set the flag read by has_error() to false. If the error
+ /// flag is set at the time when this raw_ostream's destructor is called,
+ /// report_fatal_error is called to report the error. Use clear_error()
+ /// after handling the error to avoid this behavior.
+ void clear_error() {
+ Error = false;
+ }
};
/// raw_stdout_ostream - This is a stream that always prints to stdout.
/// current_pos - Return the current position within the stream, not
/// counting the bytes currently in the buffer.
- virtual uint64_t current_pos() { return OS.size(); }
+ virtual uint64_t current_pos() const { return OS.size(); }
public:
explicit raw_string_ostream(std::string &O) : OS(O) {}
~raw_string_ostream();
/// current_pos - Return the current position within the stream, not
/// counting the bytes currently in the buffer.
- virtual uint64_t current_pos();
+ virtual uint64_t current_pos() const;
public:
/// Construct a new raw_svector_ostream.
///
explicit raw_svector_ostream(SmallVectorImpl<char> &O);
~raw_svector_ostream();
+ /// resync - This is called when the SmallVector we're appending to is changed
+ /// outside of the raw_svector_ostream's control. It is only safe to do this
+ /// if the raw_svector_ostream has previously been flushed.
+ void resync();
+
/// str - Flushes the stream contents to the target vector and return a
/// StringRef for the vector contents.
StringRef str();
/// current_pos - Return the current position within the stream, not
/// counting the bytes currently in the buffer.
- virtual uint64_t current_pos();
+ virtual uint64_t current_pos() const;
public:
explicit raw_null_ostream() {}
~raw_null_ostream();
};
+/// tool_output_file - This class behaves like a raw_fd_ostream but adds a
+/// few extra features commonly needed for compiler-like tool output files:
+/// - The file is automatically deleted if the process is killed.
+/// - The file is automatically deleted when the tool_output_file
+/// object is destroyed unless the client calls keep().
+class tool_output_file : public raw_fd_ostream {
+ std::string Filename;
+ bool Keep;
+public:
+ tool_output_file(const char *filename, std::string &ErrorInfo,
+ unsigned Flags = 0);
+
+ ~tool_output_file();
+
+ /// keep - Indicate that the tool's job wrt this output file has been
+ /// successful and the file should not be deleted.
+ void keep() { Keep = true; }
+};
+
} // end llvm namespace
#endif
projects / oota-llvm.git / blobdiff