Support: Add llvm::center_justify.

[marsupial]

Summary

Completes the set.

[ruiu]

include/llvm/Support/Format.h

132

Why don't you use Justification as a type? I think you don't need to save a few bits here.

lib/Support/raw_ostream.cpp

334–343

Using an enum value as a bitmask looks too tricky. It is probably better to write in three-way branches like this.

switch (FS.Justify) {
case JustifyRight:
  this->indent(FS.Width - Len);
  this->operator<<(FS.Str);
  break;
case JustifyCenter: {
  int PadAmount = (FS.Width - Len) / 2;
  this->indent(PadAmount);
  this->operator<<(FS.Str);  
  this->indent(Difference - PadAmount * 2);
}
case JustifyLeft:
  this->operator<<(FS.Str);
  this->indent(FS.Width - Len);
  break;
}

[marsupial]

Ok,

[ruiu]

lib/Support/raw_ostream.cpp

345

PadAmount + (Difference - (PadAmount * 2))

is the same as

PadAmount + Difference - PadAmount * 2

and thus

Difference - PadAmount

?

346

I believe we usually write this way.

  break;
}

357

nit; since the scope of this variable is very small, I wouldn't add const as it is obvious.

[ruiu]

lib/Support/raw_ostream.cpp

345

Isn't this the same as Difference - PadAmount as I wrote above?

[marsupial]

Updated

[ruiu]

It looks good to me, but I'll LGTM tomorrow to give other reviewers a chance to take a look.

[ruiu]

LGTM

include/llvm/Support/Format.h

 ///   OS << format("%0.4f", myfloat) << '\n';
 /// \endcode
 
 template <typename... Ts>
 inline format_object<Ts...> format(const char *Fmt, const Ts &... Vals) {
   return format_object<Ts...>(Fmt, Vals...);
 }
 
-/// This is a helper class used for left_justify() and right_justify().
+/// This is a helper class for left_justify, right_justify, and center_justify.
 class FormattedString {
   StringRef Str;
   unsigned Width;
-  bool RightJustify;
+  unsigned Justify : 2;
   friend class raw_ostream;
 
 public:
-    FormattedString(StringRef S, unsigned W, bool R)
-      : Str(S), Width(W), RightJustify(R) { }
+    enum Justification { JustifyLeft = 1, JustifyRight = 2, JustifyCenter = 3 };
+    FormattedString(StringRef S, unsigned W, Justification J)
+      : Str(S), Width(W), Justify(J) { }
 };
 
 /// left_justify - append spaces after string so total output is
 /// \p Width characters.  If \p Str is larger that \p Width, full string
 /// is written with no padding.
 inline FormattedString left_justify(StringRef Str, unsigned Width) {
-  return FormattedString(Str, Width, false);
+  return FormattedString(Str, Width, FormattedString::JustifyLeft);
 }
 
 /// right_justify - add spaces before string so total output is
 /// \p Width characters.  If \p Str is larger that \p Width, full string
 /// is written with no padding.
 inline FormattedString right_justify(StringRef Str, unsigned Width) {
-  return FormattedString(Str, Width, true);
+  return FormattedString(Str, Width, FormattedString::JustifyRight);
+}
+
+/// center_justify - add spaces before and after string so total output is
+/// \p Width characters.  If \p Str is larger that \p Width, full string
+/// is written with no padding.
+inline FormattedString center_justify(StringRef Str, unsigned Width) {
+  return FormattedString(Str, Width, FormattedString::JustifyCenter);
 }
 
 /// This is a helper class used for format_hex() and format_decimal().
 class FormattedNumber {
   uint64_t HexValue;
   int64_t DecValue;
   unsigned Width;
   bool Hex;

lib/Support/raw_ostream.cpp

 
 raw_ostream &raw_ostream::operator<<(const formatv_object_base &Obj) {
   SmallString<128> S;
   Obj.format(*this);
   return *this;
 }
 
 raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
-  unsigned Len = FS.Str.size(); 
-  int PadAmount = FS.Width - Len;
-  if (FS.RightJustify && (PadAmount > 0))
+  if (FS.Str.size() >= FS.Width || FS.Justify == 0) {
+    this->operator<<(FS.Str);
+    return *this;
+  }
+  const int Difference = FS.Width - FS.Str.size();
+  int PadAmount = FS.Justify == FormattedString::JustifyCenter ? Difference / 2
+                                                               : Difference;
+  if (FS.Justify & FormattedString::JustifyRight) {
     this->indent(PadAmount);
+    if (FS.Justify == FormattedString::JustifyCenter)
+      PadAmount += Difference - (PadAmount * 2);
+  }
   this->operator<<(FS.Str);
-  if (!FS.RightJustify && (PadAmount > 0))
+  if (FS.Justify & FormattedString::JustifyLeft)
     this->indent(PadAmount);
   return *this;
 }
 
 raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
   if (FN.Hex) {
     HexPrintStyle Style;
     if (FN.Upper && FN.HexPrefix)
       Style = HexPrintStyle::PrefixUpper;
     else if (FN.Upper && !FN.HexPrefix)
       Style = HexPrintStyle::Upper;
     else if (!FN.Upper && FN.HexPrefix)
       Style = HexPrintStyle::PrefixLower;
     else
       Style = HexPrintStyle::Lower;
     llvm::write_hex(*this, FN.HexValue, Style, FN.Width);
   } else {
     llvm::SmallString<16> Buffer;
     llvm::raw_svector_ostream Stream(Buffer);
     llvm::write_integer(Stream, FN.DecValue, 0, IntegerStyle::Integer);
     if (Buffer.size() < FN.Width)
       indent(FN.Width - Buffer.size());
     (*this) << Buffer;

unittests/Support/raw_ostream_test.cpp

 
 TEST(raw_ostreamTest, Justify) {  
   EXPECT_EQ("xyz   ", printToString(left_justify("xyz", 6), 6));
   EXPECT_EQ("abc",    printToString(left_justify("abc", 3), 3));
   EXPECT_EQ("big",    printToString(left_justify("big", 1), 3));
   EXPECT_EQ("   xyz", printToString(right_justify("xyz", 6), 6));
   EXPECT_EQ("abc",    printToString(right_justify("abc", 3), 3));
   EXPECT_EQ("big",    printToString(right_justify("big", 1), 3));
+  EXPECT_EQ("   on    ",    printToString(center_justify("on", 9), 9));
+  EXPECT_EQ("   off    ",    printToString(center_justify("off", 10), 10));
+  EXPECT_EQ("single ",    printToString(center_justify("single", 7), 7));
+  EXPECT_EQ("none",    printToString(center_justify("none", 1), 4));
+  EXPECT_EQ("none",    printToString(center_justify("none", 1), 1));
 }
 
 TEST(raw_ostreamTest, FormatHex) {  
   EXPECT_EQ("0x1234",     printToString(format_hex(0x1234, 6), 6));
   EXPECT_EQ("0x001234",   printToString(format_hex(0x1234, 8), 8));
   EXPECT_EQ("0x00001234", printToString(format_hex(0x1234, 10), 10));
   EXPECT_EQ("0x1234",     printToString(format_hex(0x1234, 4), 6));
   EXPECT_EQ("0xff",       printToString(format_hex(255, 4), 4));