LLVM API Documentation

Format.h

Go to the documentation of this file.
00001 //===- Format.h - Efficient printf-style formatting for streams -*- C++ -*-===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file implements the format() function, which can be used with other
00011 // LLVM subsystems to provide printf-style formatting.  This gives all the power
00012 // and risk of printf.  This can be used like this (with raw_ostreams as an
00013 // example):
00014 //
00015 //    OS << "mynumber: " << format("%4.5f", 1234.412) << '\n';
00016 //
00017 // Or if you prefer:
00018 //
00019 //  OS << format("mynumber: %4.5f\n", 1234.412);
00020 //
00021 //===----------------------------------------------------------------------===//
00022 
00023 #ifndef LLVM_SUPPORT_FORMAT_H
00024 #define LLVM_SUPPORT_FORMAT_H
00025 
00026 #include <cstdio>
00027 #ifdef WIN32
00028 #define snprintf _snprintf
00029 #endif
00030 
00031 namespace llvm {
00032 
00033 /// format_object_base - This is a helper class used for handling formatted
00034 /// output.  It is the abstract base class of a templated derived class.
00035 class format_object_base {
00036 protected:
00037   const char *Fmt;
00038   virtual void home(); // Out of line virtual method.
00039 
00040   /// snprint - Call snprintf() for this object, on the given buffer and size.
00041   virtual int snprint(char *Buffer, unsigned BufferSize) const = 0;
00042 
00043 public:
00044   format_object_base(const char *fmt) : Fmt(fmt) {}
00045   virtual ~format_object_base() {}
00046 
00047   /// print - Format the object into the specified buffer.  On success, this
00048   /// returns the length of the formatted string.  If the buffer is too small,
00049   /// this returns a length to retry with, which will be larger than BufferSize.
00050   unsigned print(char *Buffer, unsigned BufferSize) const {
00051     assert(BufferSize && "Invalid buffer size!");
00052 
00053     // Print the string, leaving room for the terminating null.
00054     int N = snprint(Buffer, BufferSize);
00055 
00056     // VC++ and old GlibC return negative on overflow, just double the size.
00057     if (N < 0)
00058       return BufferSize*2;
00059 
00060     // Other impls yield number of bytes needed, not including the final '\0'.
00061     if (unsigned(N) >= BufferSize)
00062       return N+1;
00063 
00064     // Otherwise N is the length of output (not including the final '\0').
00065     return N;
00066   }
00067 };
00068 
00069 /// format_object1 - This is a templated helper class used by the format
00070 /// function that captures the object to be formated and the format string. When
00071 /// actually printed, this synthesizes the string into a temporary buffer
00072 /// provided and returns whether or not it is big enough.
00073 template <typename T>
00074 class format_object1 : public format_object_base {
00075   T Val;
00076 public:
00077   format_object1(const char *fmt, const T &val)
00078     : format_object_base(fmt), Val(val) {
00079   }
00080 
00081   virtual int snprint(char *Buffer, unsigned BufferSize) const {
00082     return snprintf(Buffer, BufferSize, Fmt, Val);
00083   }
00084 };
00085 
00086 /// format_object2 - This is a templated helper class used by the format
00087 /// function that captures the object to be formated and the format string. When
00088 /// actually printed, this synthesizes the string into a temporary buffer
00089 /// provided and returns whether or not it is big enough.
00090 template <typename T1, typename T2>
00091 class format_object2 : public format_object_base {
00092   T1 Val1;
00093   T2 Val2;
00094 public:
00095   format_object2(const char *fmt, const T1 &val1, const T2 &val2)
00096   : format_object_base(fmt), Val1(val1), Val2(val2) {
00097   }
00098 
00099   virtual int snprint(char *Buffer, unsigned BufferSize) const {
00100     return snprintf(Buffer, BufferSize, Fmt, Val1, Val2);
00101   }
00102 };
00103 
00104 /// format_object3 - This is a templated helper class used by the format
00105 /// function that captures the object to be formated and the format string. When
00106 /// actually printed, this synthesizes the string into a temporary buffer
00107 /// provided and returns whether or not it is big enough.
00108 template <typename T1, typename T2, typename T3>
00109 class format_object3 : public format_object_base {
00110   T1 Val1;
00111   T2 Val2;
00112   T3 Val3;
00113 public:
00114   format_object3(const char *fmt, const T1 &val1, const T2 &val2,const T3 &val3)
00115     : format_object_base(fmt), Val1(val1), Val2(val2), Val3(val3) {
00116   }
00117 
00118   virtual int snprint(char *Buffer, unsigned BufferSize) const {
00119     return snprintf(Buffer, BufferSize, Fmt, Val1, Val2, Val3);
00120   }
00121 };
00122 
00123 /// format - This is a helper function that is used to produce formatted output.
00124 /// This is typically used like:  OS << format("%0.4f", myfloat) << '\n';
00125 template <typename T>
00126 inline format_object1<T> format(const char *Fmt, const T &Val) {
00127   return format_object1<T>(Fmt, Val);
00128 }
00129 
00130 /// format - This is a helper function that is used to produce formatted output.
00131 /// This is typically used like:  OS << format("%0.4f", myfloat) << '\n';
00132 template <typename T1, typename T2>
00133 inline format_object2<T1, T2> format(const char *Fmt, const T1 &Val1,
00134                                      const T2 &Val2) {
00135   return format_object2<T1, T2>(Fmt, Val1, Val2);
00136 }
00137 
00138 /// format - This is a helper function that is used to produce formatted output.
00139 /// This is typically used like:  OS << format("%0.4f", myfloat) << '\n';
00140 template <typename T1, typename T2, typename T3>
00141   inline format_object3<T1, T2, T3> format(const char *Fmt, const T1 &Val1,
00142                                            const T2 &Val2, const T3 &Val3) {
00143   return format_object3<T1, T2, T3>(Fmt, Val1, Val2, Val3);
00144 }
00145 
00146 } // end namespace llvm
00147 
00148 #endif