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
160