Skip to content

Commit

Permalink
Change variable names to match convention in SmartTextFormatter.
Browse files Browse the repository at this point in the history
  • Loading branch information
@feldergast
feldergast committed Feb 6, 2025
1 parent b98e973 commit 3029b65
Show file tree
Hide file tree
Showing 2 changed files with 78 additions and 77 deletions.
139 changes: 70 additions & 69 deletions src/sst/core/util/smartTextFormatter.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,17 +27,18 @@ namespace Util {
void
SmartTextFormatter::clear()
{
output.clear();
spaces.clear();
word.clear();
currentPosition = 0;
output_.clear();
spaces_.clear();
word_.clear();
current_position_ = 0;

indent.clear();
indent.push_back(0);
indent_.clear();
indent_.push_back(0);
}


SmartTextFormatter::SmartTextFormatter(const std::vector<int>& tabStops, int repeat) : terminalWidth(getTerminalWidth())
SmartTextFormatter::SmartTextFormatter(const std::vector<int>& tabStops, int repeat) :
terminal_width_(getTerminalWidth())
{
setTabStops(tabStops, repeat);
}
Expand All @@ -47,7 +48,7 @@ void
SmartTextFormatter::setTabStops(const std::vector<int>& stops, int repeat)
{
if ( repeat < 1 ) {
tabStops = stops;
tab_stops_ = stops;
return;
}

Expand All @@ -60,7 +61,7 @@ SmartTextFormatter::setTabStops(const std::vector<int>& stops, int repeat)
}

// Clear current tabstops
tabStops.clear();
tab_stops_.clear();

// Track the index where the repeat will start each time through
size_t repeat_index = stops.size() - repeat;
Expand All @@ -69,11 +70,11 @@ SmartTextFormatter::setTabStops(const std::vector<int>& stops, int repeat)
size_t index = 0;
int position = distances[0];
do {
tabStops.push_back(position);
tab_stops_.push_back(position);
index++;
if ( index == distances.size() ) { index = repeat_index; }
position = position + distances[index];
} while ( position < terminalWidth );
} while ( position < terminal_width_ );
}


Expand All @@ -82,36 +83,36 @@ SmartTextFormatter::append(const std::string& input)
{

for ( size_t i = 0; i < input.length(); ++i ) {
unsigned char currentChar = input[i];
unsigned char current_char = input[i];

if ( std::isspace(currentChar) ) {
if ( std::isspace(current_char) ) {

// First, check to see if we were most recently
// collecting a word. If so, we need to add it to the
// formatted string, then we can proceed to processing
// the current character.
if ( word.size() > 0 ) {
if ( currentPosition < terminalWidth ) {
if ( word_.size() > 0 ) {
if ( current_position_ < terminal_width_ ) {
// We can put the word on this line. Put in
// all the spaces we collected plus the word
output += spaces;
output += word;
spaces = "";
word = "";
output_ += spaces_;
output_ += word_;
spaces_ = "";
word_ = "";
}
else {
// Need to wrap the word. Throw away any
// preceeding spaces, put in a newline, do the
// indent, then add the word
output += '\n';
spaces = "";
output_ += '\n';
spaces_ = "";

output += std::string(indent.back(), ' ');
currentPosition = indent.back();
output_ += std::string(indent_.back(), ' ');
current_position_ = indent_.back();

output += word;
currentPosition += word.size();
word = "";
output_ += word_;
current_position_ += word_.size();
word_ = "";
}
}

Expand All @@ -120,78 +121,78 @@ SmartTextFormatter::append(const std::string& input)
// case. All other whitespace will become space.

// Handle tab characters
if ( currentChar == '\t' ) {
last_char_vert_tab = false;
int num_spaces = nextTabStop(currentPosition);
if ( current_char == '\t' ) {
last_char_vert_tab_ = false;
int num_spaces = nextTabStop(current_position_);
if ( num_spaces == -1 ) {
// Hit end of line, just wrap to next line,
// obeying indent
output += '\n';
spaces = "";
if ( indent.back() != 0 ) output += std::string(indent.back(), ' ');
currentPosition = indent.back();
output_ += '\n';
spaces_ = "";
if ( indent_.back() != 0 ) output_ += std::string(indent_.back(), ' ');
current_position_ = indent_.back();
continue;
}
// Add to the spaces object
spaces += std::string(num_spaces, ' ');
currentPosition += num_spaces;
spaces_ += std::string(num_spaces, ' ');
current_position_ += num_spaces;
}

// Handle vertical tab characters. This will simply set
// the indent to the currentPosition
else if ( currentChar == '\v' ) {
if ( last_char_vert_tab ) {
else if ( current_char == '\v' ) {
if ( last_char_vert_tab_ ) {
// If the last character was a vertical tab,
// then we were actually supposed to pop the
// current indent. However, we actually added
// another indent so need to pop two.
indent.pop_back();
indent_.pop_back();
// If someone put in two \v's before a \v,
// then we will have an empty vector if we pop
// again. Need to check for that.
if ( indent.size() != 1 ) indent.pop_back();
last_char_vert_tab = false;
if ( indent_.size() != 1 ) indent_.pop_back();
last_char_vert_tab_ = false;
}
else {
indent.push_back(currentPosition);
last_char_vert_tab = true;
indent_.push_back(current_position_);
last_char_vert_tab_ = true;
}
for ( size_t i = 0; i < indent.size(); ++i ) {}
for ( size_t i = 0; i < indent_.size(); ++i ) {}
continue;
}

// Handle carriage return characters, which will cause
// a new line that returns to the indent point
else if ( currentChar == '\r' ) {
last_char_vert_tab = false;
output += '\n';
output += std::string(indent.back(), ' ');
spaces = "";
currentPosition = indent.back();
else if ( current_char == '\r' ) {
last_char_vert_tab_ = false;
output_ += '\n';
output_ += std::string(indent_.back(), ' ');
spaces_ = "";
current_position_ = indent_.back();
}

// Handle new line characters
else if ( currentChar == '\n' ) {
output += '\n';
spaces = "";
currentPosition = 0;
else if ( current_char == '\n' ) {
output_ += '\n';
spaces_ = "";
current_position_ = 0;
// Explicit new line wipes the indent
indent.clear();
indent.push_back(0);
indent_.clear();
indent_.push_back(0);
}

// All others become a single space
else {
last_char_vert_tab = false;
spaces += ' ';
currentPosition++;
last_char_vert_tab_ = false;
spaces_ += ' ';
current_position_++;
}
}
else {
// For non space characters, we just add to the current word
last_char_vert_tab = false;
word += currentChar;
currentPosition++;
last_char_vert_tab_ = false;
word_ += current_char;
current_position_++;
}
}
}
Expand All @@ -200,22 +201,22 @@ SmartTextFormatter::append(const std::string& input)
std::string
SmartTextFormatter::str()
{
std::string ret = output;
std::string ret = output_;
// Need to handle any left over word
if ( word.size() > 0 ) {
if ( currentPosition < terminalWidth ) {
if ( word_.size() > 0 ) {
if ( current_position_ < terminal_width_ ) {
// We can put the word on this line. Put in
// all the spaces we collected plus the word
ret += spaces;
ret += word;
ret += spaces_;
ret += word_;
}
else {
// Need to wrap the word. Throw away an
// preceeding spaces, put in a newline, do the
// indent, then add the word
ret += '\n';
ret += std::string(indent.back(), ' ');
ret += word;
ret += std::string(indent_.back(), ' ');
ret += word_;
}
}
return ret;
Expand All @@ -224,7 +225,7 @@ SmartTextFormatter::str()
int
SmartTextFormatter::nextTabStop(int position)
{
for ( int tab : tabStops ) {
for ( int tab : tab_stops_ ) {
if ( tab > position ) { return tab - position; }
}
// If no more tab stops, return -1
Expand Down
16 changes: 8 additions & 8 deletions src/sst/core/util/smartTextFormatter.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,46 +33,46 @@ class SmartTextFormatter
/**
List of tab stops
*/
std::vector<int> tabStops;
std::vector<int> tab_stops_;

/**
Width of the terminal. Lines will be wrapped at this width
*/
int terminalWidth;
int terminal_width_;

/**
The output string that is being built up with calls to append
*/
std::string output;
std::string output_;

/**
Used to hold the current whitespace between words
*/
std::string spaces;
std::string spaces_;

/**
Used to hold the current word
*/
std::string word;
std::string word_;

/**
Position (column) that the next character will write at in the
current line
*/
int currentPosition = 0;
int current_position_ = 0;

/**
True if the last character was a vertical tab. This is needed
because two vertical tabs in a row will pop the most recent
indent
*/
bool last_char_vert_tab = false;
bool last_char_vert_tab_ = false;

/**
Stack of indents. Add an indent at the currentPosition by
using \v. Pop the most recent indent with \v\v.
*/
std::vector<size_t> indent = { 0 };
std::vector<size_t> indent_ = { 0 };

public:
/**
Expand Down

0 comments on commit 3029b65

Please sign in to comment.