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