[llvm] r210190 - Support: style/documentation cleanup for format

Rafael Avila de Espindola rafael.espindola at gmail.com
Wed Jun 4 09:45:53 PDT 2014


Thanks!

Sent from my iPhone

> On Jun 4, 2014, at 11:47, Saleem Abdulrasool <compnerd at compnerd.org> wrote:
> 
> Author: compnerd
> Date: Wed Jun  4 10:47:07 2014
> New Revision: 210190
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=210190&view=rev
> Log:
> Support: style/documentation cleanup for format
> 
> This is purely a documentation/whitespace cleanup for the format support
> functions.
> 
> The current style does not duplicate the function/class names in the
> documentation; conform to this style.
> 
> Additionally, there was a large amount of duplication of comments that added no
> real value.  Use block comments for the related sets of functions which are used
> for type deduction and parameter container classes.
> 
> No functional change.
> 
> Modified:
>    llvm/trunk/include/llvm/Support/Format.h
> 
> Modified: llvm/trunk/include/llvm/Support/Format.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/Format.h?rev=210190&r1=210189&r2=210190&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/Format.h (original)
> +++ llvm/trunk/include/llvm/Support/Format.h Wed Jun  4 10:47:07 2014
> @@ -36,23 +36,23 @@
> 
> namespace llvm {
> 
> -/// format_object_base - This is a helper class used for handling formatted
> -/// output.  It is the abstract base class of a templated derived class.
> +/// This is a helper class used for handling formatted output.  It is the
> +/// abstract base class of a templated derived class.
> class format_object_base {
> protected:
>   const char *Fmt;
>   virtual void home(); // Out of line virtual method.
> 
> -  /// snprint - Call snprintf() for this object, on the given buffer and size.
> +  /// Call snprintf() for this object, on the given buffer and size.
>   virtual int snprint(char *Buffer, unsigned BufferSize) const = 0;
> 
> public:
>   format_object_base(const char *fmt) : Fmt(fmt) {}
>   virtual ~format_object_base() {}
> 
> -  /// print - Format the object into the specified buffer.  On success, this
> -  /// returns the length of the formatted string.  If the buffer is too small,
> -  /// this returns a length to retry with, which will be larger than BufferSize.
> +  /// Format the object into the specified buffer.  On success, this returns
> +  /// the length of the formatted string.  If the buffer is too small, this
> +  /// returns a length to retry with, which will be larger than BufferSize.
>   unsigned print(char *Buffer, unsigned BufferSize) const {
>     assert(BufferSize && "Invalid buffer size!");
> 
> @@ -61,21 +61,23 @@ public:
> 
>     // VC++ and old GlibC return negative on overflow, just double the size.
>     if (N < 0)
> -      return BufferSize*2;
> +      return BufferSize * 2;
> 
> -    // Other impls yield number of bytes needed, not including the final '\0'.
> +    // Other implementations yield number of bytes needed, not including the
> +    // final '\0'.
>     if (unsigned(N) >= BufferSize)
> -      return N+1;
> +      return N + 1;
> 
>     // Otherwise N is the length of output (not including the final '\0').
>     return N;
>   }
> };
> 
> -/// format_object1 - This is a templated helper class used by the format
> -/// function that captures the object to be formated and the format string. When
> -/// actually printed, this synthesizes the string into a temporary buffer
> -/// provided and returns whether or not it is big enough.
> +/// These are templated helper classes used by the format function that
> +/// capture the object to be formated and the format string. When actually
> +/// printed, this synthesizes the string into a temporary buffer provided and
> +/// returns whether or not it is big enough.
> +
> template <typename T>
> class format_object1 : public format_object_base {
>   T Val;
> @@ -89,10 +91,6 @@ public:
>   }
> };
> 
> -/// format_object2 - This is a templated helper class used by the format
> -/// function that captures the object to be formated and the format string. When
> -/// actually printed, this synthesizes the string into a temporary buffer
> -/// provided and returns whether or not it is big enough.
> template <typename T1, typename T2>
> class format_object2 : public format_object_base {
>   T1 Val1;
> @@ -107,10 +105,6 @@ public:
>   }
> };
> 
> -/// format_object3 - This is a templated helper class used by the format
> -/// function that captures the object to be formated and the format string. When
> -/// actually printed, this synthesizes the string into a temporary buffer
> -/// provided and returns whether or not it is big enough.
> template <typename T1, typename T2, typename T3>
> class format_object3 : public format_object_base {
>   T1 Val1;
> @@ -126,10 +120,6 @@ public:
>   }
> };
> 
> -/// format_object4 - This is a templated helper class used by the format
> -/// function that captures the object to be formated and the format string. When
> -/// actually printed, this synthesizes the string into a temporary buffer
> -/// provided and returns whether or not it is big enough.
> template <typename T1, typename T2, typename T3, typename T4>
> class format_object4 : public format_object_base {
>   T1 Val1;
> @@ -147,10 +137,6 @@ public:
>   }
> };
> 
> -/// format_object5 - This is a templated helper class used by the format
> -/// function that captures the object to be formated and the format string. When
> -/// actually printed, this synthesizes the string into a temporary buffer
> -/// provided and returns whether or not it is big enough.
> template <typename T1, typename T2, typename T3, typename T4, typename T5>
> class format_object5 : public format_object_base {
>   T1 Val1;
> @@ -170,10 +156,6 @@ public:
>   }
> };
> 
> -/// format_object6 - This is a templated helper class used by the format
> -/// function that captures the object to be formated and the format string. When
> -/// actually printed, this synthesizes the string into a temporary buffer
> -/// provided and returns whether or not it is big enough.
> template <typename T1, typename T2, typename T3, typename T4, typename T5,
>           typename T6>
> class format_object6 : public format_object_base {
> @@ -194,47 +176,32 @@ public:
>   }
> };
> 
> -/// This is a helper function that is used to produce formatted output.
> +/// These are helper functions used to produce formatted output.  They use
> +/// template type deduction to construct the appropriate instance of the
> +/// format_object class to simplify their construction.
> ///
> /// This is typically used like:
> /// \code
> ///   OS << format("%0.4f", myfloat) << '\n';
> /// \endcode
> +
> template <typename T>
> inline format_object1<T> format(const char *Fmt, const T &Val) {
>   return format_object1<T>(Fmt, Val);
> }
> 
> -/// This is a helper function that is used to produce formatted output.
> -///
> -/// This is typically used like:
> -/// \code
> -///   OS << format("%0.4f", myfloat) << '\n';
> -/// \endcode
> template <typename T1, typename T2>
> inline format_object2<T1, T2> format(const char *Fmt, const T1 &Val1,
>                                      const T2 &Val2) {
>   return format_object2<T1, T2>(Fmt, Val1, Val2);
> }
> 
> -/// This is a helper function that is used to produce formatted output.
> -///
> -/// This is typically used like:
> -/// \code
> -///   OS << format("%0.4f", myfloat) << '\n';
> -/// \endcode
> template <typename T1, typename T2, typename T3>
>   inline format_object3<T1, T2, T3> format(const char *Fmt, const T1 &Val1,
>                                            const T2 &Val2, const T3 &Val3) {
>   return format_object3<T1, T2, T3>(Fmt, Val1, Val2, Val3);
> }
> 
> -/// This is a helper function that is used to produce formatted output.
> -///
> -/// This is typically used like:
> -/// \code
> -///   OS << format("%0.4f", myfloat) << '\n';
> -/// \endcode
> template <typename T1, typename T2, typename T3, typename T4>
> inline format_object4<T1, T2, T3, T4> format(const char *Fmt, const T1 &Val1,
>                                              const T2 &Val2, const T3 &Val3,
> @@ -242,12 +209,6 @@ inline format_object4<T1, T2, T3, T4> fo
>   return format_object4<T1, T2, T3, T4>(Fmt, Val1, Val2, Val3, Val4);
> }
> 
> -/// This is a helper function that is used to produce formatted output.
> -///
> -/// This is typically used like:
> -/// \code
> -///   OS << format("%0.4f", myfloat) << '\n';
> -/// \endcode
> template <typename T1, typename T2, typename T3, typename T4, typename T5>
> inline format_object5<T1, T2, T3, T4, T5> format(const char *Fmt,const T1 &Val1,
>                                              const T2 &Val2, const T3 &Val3,
> @@ -255,12 +216,6 @@ inline format_object5<T1, T2, T3, T4, T5
>   return format_object5<T1, T2, T3, T4, T5>(Fmt, Val1, Val2, Val3, Val4, Val5);
> }
> 
> -/// This is a helper function that is used to produce formatted output.
> -///
> -/// This is typically used like:
> -/// \code
> -///   OS << format("%0.4f", myfloat) << '\n';
> -/// \endcode
> template <typename T1, typename T2, typename T3, typename T4, typename T5,
>           typename T6>
> inline format_object6<T1, T2, T3, T4, T5, T6>
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits




More information about the llvm-commits mailing list