include/llvm/Support/circular_raw_ostream.h

   1 //===-- llvm/Support/circular_raw_ostream.h - Buffered streams --*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains raw_ostream implementations for streams to do circular
  10 // buffering of their output.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_SUPPORT_CIRCULAR_RAW_OSTREAM_H
  15 #define LLVM_SUPPORT_CIRCULAR_RAW_OSTREAM_H
  16
  17 #include "llvm/Support/raw_ostream.h"
  18
  19 namespace llvm {
  20   /// circular_raw_ostream - A raw_ostream which *can* save its data
  21   /// to a circular buffer, or can pass it through directly to an
  22   /// underlying stream if specified with a buffer of zero.
  23   ///
  24   class circular_raw_ostream : public raw_ostream {
  25   public:
  26     /// TAKE_OWNERSHIP - Tell this stream that it owns the underlying
  27     /// stream and is responsible for cleanup, memory management
  28     /// issues, etc.
  29     ///
  30     static const bool TAKE_OWNERSHIP = true;
  31
  32     /// REFERENCE_ONLY - Tell this stream it should not manage the
  33     /// held stream.
  34     ///
  35     static const bool REFERENCE_ONLY = false;
  36
  37   private:
  38     /// TheStream - The real stream we output to. We set it to be
  39     /// unbuffered, since we're already doing our own buffering.
  40     ///
  41     raw_ostream *TheStream;
  42
  43     /// OwnsStream - Are we responsible for managing the underlying
  44     /// stream?
  45     ///
  46     bool OwnsStream;
  47
  48     /// BufferSize - The size of the buffer in bytes.
  49     ///
  50     size_t BufferSize;
  51
  52     /// BufferArray - The actual buffer storage.
  53     ///
  54     char *BufferArray;
  55
  56     /// Cur - Pointer to the current output point in BufferArray.
  57     ///
  58     char *Cur;
  59
  60     /// Filled - Indicate whether the buffer has been completely
  61     /// filled.  This helps avoid garbage output.
  62     ///
  63     bool Filled;
  64
  65     /// Banner - A pointer to a banner to print before dumping the
  66     /// log.
  67     ///
  68     const char *Banner;
  69
  70     /// flushBuffer - Dump the contents of the buffer to Stream.
  71     ///
  72     void flushBuffer() {
  73       if (Filled)
  74         // Write the older portion of the buffer.
  75         TheStream->write(Cur, BufferArray + BufferSize - Cur);
  76       // Write the newer portion of the buffer.
  77       TheStream->write(BufferArray, Cur - BufferArray);
  78       Cur = BufferArray;
  79       Filled = false;
  80     }
  81
  82     void write_impl(const char *Ptr, size_t Size) override;
  83
  84     /// current_pos - Return the current position within the stream,
  85     /// not counting the bytes currently in the buffer.
  86     ///
  87     uint64_t current_pos() const override {
  88       // This has the same effect as calling TheStream.current_pos(),
  89       // but that interface is private.
  90       return TheStream->tell() - TheStream->GetNumBytesInBuffer();
  91     }
  92
  93   public:
  94     /// circular_raw_ostream - Construct an optionally
  95     /// circular-buffered stream, handing it an underlying stream to
  96     /// do the "real" output.
  97     ///
  98     /// As a side effect, if BuffSize is nonzero, the given Stream is
  99     /// set to be Unbuffered.  This is because circular_raw_ostream
 100     /// does its own buffering, so it doesn't want another layer of
 101     /// buffering to be happening underneath it.
 102     ///
 103     /// "Owns" tells the circular_raw_ostream whether it is
 104     /// responsible for managing the held stream, doing memory
 105     /// management of it, etc.
 106     ///
 107     circular_raw_ostream(raw_ostream &Stream, const char *Header,
 108                          size_t BuffSize = 0, bool Owns = REFERENCE_ONLY)
 109         : raw_ostream(/*unbuffered*/ true), TheStream(nullptr),
 110           OwnsStream(Owns), BufferSize(BuffSize), BufferArray(nullptr),
 111           Filled(false), Banner(Header) {
 112       if (BufferSize != 0)
 113         BufferArray = new char[BufferSize];
 114       Cur = BufferArray;
 115       setStream(Stream, Owns);
 116     }
 117
 118     ~circular_raw_ostream() override {
 119       flush();
 120       flushBufferWithBanner();
 121       releaseStream();
 122       delete[] BufferArray;
 123     }
 124
 125     bool is_displayed() const override {
 126       return TheStream->is_displayed();
 127     }
 128
 129     /// setStream - Tell the circular_raw_ostream to output a
 130     /// different stream.  "Owns" tells circular_raw_ostream whether
 131     /// it should take responsibility for managing the underlying
 132     /// stream.
 133     ///
 134     void setStream(raw_ostream &Stream, bool Owns = REFERENCE_ONLY) {
 135       releaseStream();
 136       TheStream = &Stream;
 137       OwnsStream = Owns;
 138     }
 139
 140     /// flushBufferWithBanner - Force output of the buffer along with
 141     /// a small header.
 142     ///
 143     void flushBufferWithBanner();
 144
 145   private:
 146     /// releaseStream - Delete the held stream if needed. Otherwise,
 147     /// transfer the buffer settings from this circular_raw_ostream
 148     /// back to the underlying stream.
 149     ///
 150     void releaseStream() {
 151       if (!TheStream)
 152         return;
 153       if (OwnsStream)
 154         delete TheStream;
 155     }
 156   };
 157 } // end llvm namespace
 158
 159 #endif