CbC/CbC_llvm: include/llvm/Support/raw

comparison include/llvm/Support/raw_ostream.h @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	c2174574ed3a

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
 #ifndef LLVM_SUPPORT_RAW_OSTREAM_H
 #define LLVM_SUPPORT_RAW_OSTREAM_H
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/DataTypes.h"
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
 #include <system_error>
 namespace llvm {
 class formatv_object_base;
 class format_object_base;
 class FormattedString;
 class FormattedNumber;
 class FormattedBytes;
-template <typename T> class SmallVectorImpl;
 namespace sys {
 namespace fs {
 enum OpenFlags : unsigned;
-}
+} // end namespace fs
-}
+} // end namespace sys
 /// This class implements an extremely fast bulk output stream that can *only*
 /// output to a stream.  It does not support seeking, reopening, rewinding, line
 /// buffered disciplines etc. It is a simple buffer that outputs
 /// a chunk at a time.
 class raw_ostream {
 private:
-void operator=(const raw_ostream &) = delete;
-raw_ostream(const raw_ostream &) = delete;
 /// The buffer is handled in such a way that the buffer is
 /// uninitialized, unbuffered, or out of space when OutBufCur >=
 /// OutBufEnd. Thus a single comparison suffices to determine if we
 /// need to take the slow path to write a single character.
 ///
 } BufferMode;
 public:
 // color order matches ANSI escape sequence, don't change
 enum Colors {
-BLACK=0,
+BLACK = 0,
 RED,
 GREEN,
 YELLOW,
 BLUE,
 MAGENTA,
 : BufferMode(unbuffered ? Unbuffered : InternalBuffer) {
 // Start out ready to flush.
 OutBufStart = OutBufEnd = OutBufCur = nullptr;
 }
+raw_ostream(const raw_ostream &) = delete;
+void operator=(const raw_ostream &) = delete;
 virtual ~raw_ostream();
 /// tell - Return the current offset with the file.
 uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
 raw_ostream &operator<<(const std::string &Str) {
 // Avoid the fast path, it would only increase code size for a marginal win.
 return write(Str.data(), Str.length());
 }
-raw_ostream &operator<<(const llvm::SmallVectorImpl<char> &Str) {
+raw_ostream &operator<<(const SmallVectorImpl<char> &Str) {
 return write(Str.data(), Str.size());
 }
 raw_ostream &operator<<(unsigned long N);
 raw_ostream &operator<<(long N);
 raw_ostream &operator<<(unsigned long long N);
 raw_ostream &operator<<(long long N);
 raw_ostream &operator<<(const void *P);
 raw_ostream &operator<<(unsigned int N) {
 return this->operator<<(static_cast<unsigned long>(N));
 }
 raw_ostream &operator<<(int N) {
 raw_ostream &operator<<(double N);
 /// Output \p N in hexadecimal, without any prefix or padding.
 raw_ostream &write_hex(unsigned long long N);
+/// Output a formatted UUID with dash separators.
+using uuid_t = uint8_t[16];
+raw_ostream &write_uuid(const uuid_t UUID);
 /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't
 /// satisfy std::isprint into an escape sequence.
 raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false);
 ///
 class raw_fd_ostream : public raw_pwrite_stream {
 int FD;
 bool ShouldClose;
-/// Error This flag is true if an error of any kind has been detected.
+std::error_code EC;
-///
-bool Error;
 uint64_t pos;
 bool SupportsSeeking;
 /// Determine an efficient buffer size.
 size_t preferred_buffer_size() const override;
 /// Set the flag indicating that an output error has been encountered.
-void error_detected() { Error = true; }
+void error_detected(std::error_code EC) { this->EC = EC; }
 public:
 /// Open the specified file for writing. If an error occurs, information
 /// about the error is put into EC, and the stream should be immediately
 /// destroyed;
 /// \p Flags allows optional flags to control how the file will be opened.
 ///
 /// 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
+/// STDOUT_FILENO instead of opening a file. This will not close the stdout
-/// itself to own the file descriptor. In particular, it will close the
+/// descriptor.
-/// file descriptor when it is done (this is necessary to detect
-/// output errors).
 raw_fd_ostream(StringRef Filename, std::error_code &EC,
 sys::fs::OpenFlags Flags);
 /// FD is the file descriptor that this writes to.  If ShouldClose is true,
-/// this closes the file when the stream is destroyed.
+/// this closes the file when the stream is destroyed. If FD is for stdout or
+/// stderr, it will not be closed.
 raw_fd_ostream(int fd, bool shouldClose, bool unbuffered=false);
 ~raw_fd_ostream() override;
 /// Manually flush the stream and close the file. Note that this does not call
 raw_ostream &reverseColor() override;
 bool is_displayed() const override;
 bool has_colors() const override;
+std::error_code error() const { return EC; }
 /// 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 stream has been closed.
-bool has_error() const {
+bool has_error() const { return bool(EC); }
-return 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.
 ///
 ///   "Errors should never pass silently.
 ///    Unless explicitly silenced."
 ///      - from The Zen of Python, by Tim Peters
 ///
-void clear_error() {
+void clear_error() { EC = std::error_code(); }
-Error = false;
-}
 };
 /// This returns a reference to a raw_ostream for standard output. Use it like:
 /// outs() << "foo" << "bar";
 raw_ostream &outs();
 /// \param O The vector to write to; this should generally have at least 128
 /// bytes free to avoid any extraneous memory overhead.
 explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
 SetUnbuffered();
 }
-~raw_svector_ostream() override {}
+~raw_svector_ostream() override = default;
 void flush() = delete;
 /// Return a StringRef for the vector contents.
 StringRef str() { return StringRef(OS.data(), OS.size()); }
 /// Return the current position within the stream, not counting the bytes
 /// currently in the buffer.
 uint64_t current_pos() const override;
 public:
-explicit raw_null_ostream() {}
+explicit raw_null_ostream() = default;
 ~raw_null_ostream() override;
 };
 class buffer_ostream : public raw_svector_ostream {
 raw_ostream &OS;
 public:
 buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {}
 ~buffer_ostream() override { OS << str(); }
 };
-} // end llvm namespace
+} // end namespace llvm
 #endif // LLVM_SUPPORT_RAW_OSTREAM_H

Mercurial > hg > CbC > CbC_llvm

comparison include/llvm/Support/raw_ostream.h @ 121:803732b1fca8