From f28e3c501e033f103405c03a4bbf848cb6e67a2a Mon Sep 17 00:00:00 2001 From: Daniel Malea Date: Wed, 8 May 2013 20:29:10 +0000 Subject: Add line tracking support to FormattedStream - previously formatted_raw_ostream tracked columns, now it tracks lines too - used by (upcoming) DebugIR pass to know the line number to connect to each IR instruction git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@181463 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/FormattedStream.h | 26 +++++++++++++------- lib/Support/FormattedStream.cpp | 45 +++++++++++++++++++--------------- 2 files changed, 42 insertions(+), 29 deletions(-) diff --git a/include/llvm/Support/FormattedStream.h b/include/llvm/Support/FormattedStream.h index 2e4bd5aeca..18ee048396 100644 --- a/include/llvm/Support/FormattedStream.h +++ b/include/llvm/Support/FormattedStream.h @@ -16,11 +16,13 @@ #define LLVM_SUPPORT_FORMATTEDSTREAM_H #include "llvm/Support/raw_ostream.h" +#include namespace llvm { /// formatted_raw_ostream - A raw_ostream that wraps another one and keeps track -/// of column position, allowing padding out to specific column boundaries. +/// of line and column position, allowing padding out to specific column +/// boundaries and querying the number of lines written to the stream. /// class formatted_raw_ostream : public raw_ostream { public: @@ -44,11 +46,11 @@ private: /// bool DeleteStream; - /// ColumnScanned - The current output column of the data that's + /// Position - The current output column and line of the data that's /// been flushed and the portion of the buffer that's been - /// scanned. The column scheme is zero-based. + /// scanned. The line and column scheme is zero-based. /// - unsigned ColumnScanned; + std::pair Position; /// Scanned - This points to one past the last character in the /// buffer we've scanned. @@ -66,10 +68,10 @@ private: return TheStream->tell(); } - /// ComputeColumn - Examine the given output buffer and figure out which - /// column we end up in after output. + /// ComputePosition - Examine the given output buffer and figure out the new + /// position after output. /// - void ComputeColumn(const char *Ptr, size_t size); + void ComputePosition(const char *Ptr, size_t size); public: /// formatted_raw_ostream - Open the specified file for @@ -83,11 +85,11 @@ public: /// underneath it. /// formatted_raw_ostream(raw_ostream &Stream, bool Delete = false) - : raw_ostream(), TheStream(0), DeleteStream(false), ColumnScanned(0) { + : raw_ostream(), TheStream(0), DeleteStream(false), Position(0, 0) { setStream(Stream, Delete); } explicit formatted_raw_ostream() - : raw_ostream(), TheStream(0), DeleteStream(false), ColumnScanned(0) { + : raw_ostream(), TheStream(0), DeleteStream(false), Position(0, 0) { Scanned = 0; } @@ -122,6 +124,12 @@ public: /// \param NewCol - The column to move to. formatted_raw_ostream &PadToColumn(unsigned NewCol); + /// getColumn - Return the column number + unsigned getColumn() { return Position.first; } + + /// getLine - Return the line number + unsigned getLine() { return Position.second; } + private: void releaseStream() { // Delete the stream if needed. Otherwise, transfer the buffer diff --git a/lib/Support/FormattedStream.cpp b/lib/Support/FormattedStream.cpp index 231ae48759..9febf664f2 100644 --- a/lib/Support/FormattedStream.cpp +++ b/lib/Support/FormattedStream.cpp @@ -17,38 +17,43 @@ using namespace llvm; -/// CountColumns - Examine the given char sequence and figure out which -/// column we end up in after output. +/// UpdatePosition - Examine the given char sequence and figure out which +/// column we end up in after output, and how many line breaks are contained. /// -static unsigned CountColumns(unsigned Column, const char *Ptr, size_t Size) { - // Keep track of the current column by scanning the string for - // special characters +static void UpdatePosition(std::pair &Position, const char *Ptr, size_t Size) { + unsigned &Column = Position.first; + unsigned &Line = Position.second; + // Keep track of the current column and line by scanning the string for + // special characters for (const char *End = Ptr + Size; Ptr != End; ++Ptr) { ++Column; - if (*Ptr == '\n' || *Ptr == '\r') + switch (*Ptr) { + case '\n': + Line += 1; + case '\r': Column = 0; - else if (*Ptr == '\t') + break; + case '\t': // Assumes tab stop = 8 characters. Column += (8 - (Column & 0x7)) & 0x7; + break; + } } - - return Column; } -/// ComputeColumn - Examine the current output and figure out which -/// column we end up in after output. -void formatted_raw_ostream::ComputeColumn(const char *Ptr, size_t Size) { +/// ComputePosition - Examine the current output and update line and column +/// counts. +void formatted_raw_ostream::ComputePosition(const char *Ptr, size_t Size) { // If our previous scan pointer is inside the buffer, assume we already // scanned those bytes. This depends on raw_ostream to not change our buffer // in unexpected ways. - if (Ptr <= Scanned && Scanned <= Ptr + Size) { + if (Ptr <= Scanned && Scanned <= Ptr + Size) // Scan all characters added since our last scan to determine the new // column. - ColumnScanned = CountColumns(ColumnScanned, Scanned, - Size - (Scanned - Ptr)); - } else - ColumnScanned = CountColumns(ColumnScanned, Ptr, Size); + UpdatePosition(Position, Scanned, Size - (Scanned - Ptr)); + else + UpdatePosition(Position, Ptr, Size); // Update the scanning pointer. Scanned = Ptr + Size; @@ -60,16 +65,16 @@ void formatted_raw_ostream::ComputeColumn(const char *Ptr, size_t Size) { /// formatted_raw_ostream &formatted_raw_ostream::PadToColumn(unsigned NewCol) { // Figure out what's in the buffer and add it to the column count. - ComputeColumn(getBufferStart(), GetNumBytesInBuffer()); + ComputePosition(getBufferStart(), GetNumBytesInBuffer()); // Output spaces until we reach the desired column. - indent(std::max(int(NewCol - ColumnScanned), 1)); + indent(std::max(int(NewCol - getColumn()), 1)); return *this; } void formatted_raw_ostream::write_impl(const char *Ptr, size_t Size) { // Figure out what's in the buffer and add it to the column count. - ComputeColumn(Ptr, Size); + ComputePosition(Ptr, Size); // Write the data to the underlying stream (which is unbuffered, so // the data will be immediately written out). -- cgit v1.2.3