LLVM API Documentation
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