[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