Line data    Source code

       1             : //===-- llvm/Support/FormattedStream.cpp - Formatted 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 the implementation of formatted_raw_ostream.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/Support/FormattedStream.h"
      15             : #include "llvm/Support/Debug.h"
      16             : #include "llvm/Support/raw_ostream.h"
      17             : #include <algorithm>
      18             : 
      19             : using namespace llvm;
      20             : 
      21             : /// UpdatePosition - Examine the given char sequence and figure out which
      22             : /// column we end up in after output, and how many line breaks are contained.
      23             : ///
      24     5320934 : static void UpdatePosition(std::pair<unsigned, unsigned> &Position, const char *Ptr, size_t Size) {
      25             :   unsigned &Column = Position.first;
      26             :   unsigned &Line = Position.second;
      27             : 
      28             :   // Keep track of the current column and line by scanning the string for
      29             :   // special characters
      30   410031865 :   for (const char *End = Ptr + Size; Ptr != End; ++Ptr) {
      31   404710931 :     ++Column;
      32   404710931 :     switch (*Ptr) {
      33    10390222 :     case '\n':
      34    10390222 :       Line += 1;
      35             :       LLVM_FALLTHROUGH;
      36    10390222 :     case '\r':
      37    10390222 :       Column = 0;
      38    10390222 :       break;
      39     7385143 :     case '\t':
      40             :       // Assumes tab stop = 8 characters.
      41     7385143 :       Column += (8 - (Column & 0x7)) & 0x7;
      42     7385143 :       break;
      43             :     }
      44             :   }
      45     5320934 : }
      46             : 
      47             : /// ComputePosition - Examine the current output and update line and column
      48             : /// counts.
      49     5320934 : void formatted_raw_ostream::ComputePosition(const char *Ptr, size_t Size) {
      50             :   // If our previous scan pointer is inside the buffer, assume we already
      51             :   // scanned those bytes. This depends on raw_ostream to not change our buffer
      52             :   // in unexpected ways.
      53     5320934 :   if (Ptr <= Scanned && Scanned <= Ptr + Size)
      54             :     // Scan all characters added since our last scan to determine the new
      55             :     // column.
      56     3374592 :     UpdatePosition(Position, Scanned, Size - (Scanned - Ptr));
      57             :   else
      58     1946342 :     UpdatePosition(Position, Ptr, Size);
      59             : 
      60             :   // Update the scanning pointer.
      61     5320934 :   Scanned = Ptr + Size;
      62     5320934 : }
      63             : 
      64             : /// PadToColumn - Align the output to some column number.
      65             : ///
      66             : /// \param NewCol - The column to move to.
      67             : ///
      68     3374600 : formatted_raw_ostream &formatted_raw_ostream::PadToColumn(unsigned NewCol) {
      69             :   // Figure out what's in the buffer and add it to the column count.
      70     6749200 :   ComputePosition(getBufferStart(), GetNumBytesInBuffer());
      71             : 
      72             :   // Output spaces until we reach the desired column.
      73     3822011 :   indent(std::max(int(NewCol - getColumn()), 1));
      74     3374600 :   return *this;
      75             : }
      76             : 
      77     1946334 : void formatted_raw_ostream::write_impl(const char *Ptr, size_t Size) {
      78             :   // Figure out what's in the buffer and add it to the column count.
      79     1946334 :   ComputePosition(Ptr, Size);
      80             : 
      81             :   // Write the data to the underlying stream (which is unbuffered, so
      82             :   // the data will be immediately written out).
      83     1946334 :   TheStream->write(Ptr, Size);
      84             : 
      85             :   // Reset the scanning pointer.
      86     1946333 :   Scanned = nullptr;
      87     1946333 : }
      88             : 
      89             : /// fouts() - This returns a reference to a formatted_raw_ostream for
      90             : /// standard output.  Use it like: fouts() << "foo" << "bar";
      91           0 : formatted_raw_ostream &llvm::fouts() {
      92           0 :   static formatted_raw_ostream S(outs());
      93           0 :   return S;
      94             : }
      95             : 
      96             : /// ferrs() - This returns a reference to a formatted_raw_ostream for
      97             : /// standard error.  Use it like: ferrs() << "foo" << "bar";
      98           0 : formatted_raw_ostream &llvm::ferrs() {
      99           0 :   static formatted_raw_ostream S(errs());
     100           0 :   return S;
     101             : }
     102             : 
     103             : /// fdbgs() - This returns a reference to a formatted_raw_ostream for
     104             : /// the debug stream.  Use it like: fdbgs() << "foo" << "bar";
     105           0 : formatted_raw_ostream &llvm::fdbgs() {
     106           0 :   static formatted_raw_ostream S(dbgs());
     107           0 :   return S;
     108             : }