Format.h revision ffbbf314f1740b9d73c5af1ad1aa3e731dac026b
1//===- Format.h - Efficient printf-style formatting for streams -*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the format() function, which can be used with other 11// LLVM subsystems to provide printf-style formatting. This gives all the power 12// and risk of printf. This can be used like this (with raw_ostreams as an 13// example): 14// 15// OS << "mynumber: " << format("%4.5f", 1234.412) << '\n'; 16// 17// Or if you prefer: 18// 19// OS << format("mynumber: %4.5f\n", 1234.412); 20// 21//===----------------------------------------------------------------------===// 22 23#ifndef LLVM_SUPPORT_FORMAT_H 24#define LLVM_SUPPORT_FORMAT_H 25 26#include <cstdio> 27#ifdef WIN32 28#define snprintf _snprintf 29#endif 30 31namespace llvm { 32 33/// format_object_base - This is a helper class used for handling formatted 34/// output. It is the abstract base class of a templated derived class. 35class format_object_base { 36protected: 37 const char *Fmt; 38 virtual void home(); // Out of line virtual method. 39 40 /// snprint - Call snprintf() for this object, on the given buffer and size. 41 virtual int snprint(char *Buffer, unsigned BufferSize) const = 0; 42 43public: 44 format_object_base(const char *fmt) : Fmt(fmt) {} 45 virtual ~format_object_base() {} 46 47 /// print - Format the object into the specified buffer. On success, this 48 /// returns the length of the formatted string. If the buffer is too small, 49 /// this returns a length to retry with, which will be larger than BufferSize. 50 unsigned print(char *Buffer, unsigned BufferSize) const { 51 assert(BufferSize && "Invalid buffer size!"); 52 53 // Print the string, leaving room for the terminating null. 54 int N = snprint(Buffer, BufferSize); 55 56 // VC++ and old GlibC return negative on overflow, just double the size. 57 if (N < 0) 58 return BufferSize*2; 59 60 // Other impls yield number of bytes needed, not including the final '\0'. 61 if (unsigned(N) >= BufferSize) 62 return N+1; 63 64 // Otherwise N is the length of output (not including the final '\0'). 65 return N; 66 } 67}; 68 69/// format_object1 - This is a templated helper class used by the format 70/// function that captures the object to be formated and the format string. When 71/// actually printed, this synthesizes the string into a temporary buffer 72/// provided and returns whether or not it is big enough. 73template <typename T> 74class format_object1 : public format_object_base { 75 T Val; 76public: 77 format_object1(const char *fmt, const T &val) 78 : format_object_base(fmt), Val(val) { 79 } 80 81 virtual int snprint(char *Buffer, unsigned BufferSize) const { 82 return snprintf(Buffer, BufferSize, Fmt, Val); 83 } 84}; 85 86/// format_object2 - This is a templated helper class used by the format 87/// function that captures the object to be formated and the format string. When 88/// actually printed, this synthesizes the string into a temporary buffer 89/// provided and returns whether or not it is big enough. 90template <typename T1, typename T2> 91class format_object2 : public format_object_base { 92 T1 Val1; 93 T2 Val2; 94public: 95 format_object2(const char *fmt, const T1 &val1, const T2 &val2) 96 : format_object_base(fmt), Val1(val1), Val2(val2) { 97 } 98 99 virtual int snprint(char *Buffer, unsigned BufferSize) const { 100 return snprintf(Buffer, BufferSize, Fmt, Val1, Val2); 101 } 102}; 103 104/// format_object3 - This is a templated helper class used by the format 105/// function that captures the object to be formated and the format string. When 106/// actually printed, this synthesizes the string into a temporary buffer 107/// provided and returns whether or not it is big enough. 108template <typename T1, typename T2, typename T3> 109class format_object3 : public format_object_base { 110 T1 Val1; 111 T2 Val2; 112 T3 Val3; 113public: 114 format_object3(const char *fmt, const T1 &val1, const T2 &val2,const T3 &val3) 115 : format_object_base(fmt), Val1(val1), Val2(val2), Val3(val3) { 116 } 117 118 virtual int snprint(char *Buffer, unsigned BufferSize) const { 119 return snprintf(Buffer, BufferSize, Fmt, Val1, Val2, Val3); 120 } 121}; 122 123/// format - This is a helper function that is used to produce formatted output. 124/// This is typically used like: OS << format("%0.4f", myfloat) << '\n'; 125template <typename T> 126inline format_object1<T> format(const char *Fmt, const T &Val) { 127 return format_object1<T>(Fmt, Val); 128} 129 130/// format - This is a helper function that is used to produce formatted output. 131/// This is typically used like: OS << format("%0.4f", myfloat) << '\n'; 132template <typename T1, typename T2> 133inline format_object2<T1, T2> format(const char *Fmt, const T1 &Val1, 134 const T2 &Val2) { 135 return format_object2<T1, T2>(Fmt, Val1, Val2); 136} 137 138/// format - This is a helper function that is used to produce formatted output. 139/// This is typically used like: OS << format("%0.4f", myfloat) << '\n'; 140template <typename T1, typename T2, typename T3> 141 inline format_object3<T1, T2, T3> format(const char *Fmt, const T1 &Val1, 142 const T2 &Val2, const T3 &Val3) { 143 return format_object3<T1, T2, T3>(Fmt, Val1, Val2, Val3); 144} 145 146} // end namespace llvm 147 148#endif 149