mirror of
https://github.com/fmtlib/fmt.git
synced 2024-12-24 12:14:26 +00:00
Initial import
This commit is contained in:
Victor Zverovich
parent
ec27d5d8a1
commit
b076df4f80
184
format.cc
Normal file
184
format.cc
Normal file
@ -0,0 +1,184 @@
|
||||
/*
|
||||
Small, safe and fast printf-like formatting library for C++
|
||||
Author: Victor Zverovich
|
||||
*/
|
||||
|
||||
#include "format.h"
|
||||
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
|
||||
using std::size_t;
|
||||
|
||||
template <typename T>
|
||||
void fmt::Formatter::FormatArg(
|
||||
const char *format, const T &arg, int width, int precision) {
|
||||
size_t offset = buffer_.size();
|
||||
buffer_.resize(buffer_.capacity());
|
||||
for (;;) {
|
||||
size_t size = buffer_.size() - offset;
|
||||
int n = 0;
|
||||
if (width < 0) {
|
||||
n = precision < 0 ?
|
||||
snprintf(&buffer_[offset], size, format, arg) :
|
||||
snprintf(&buffer_[offset], size, format, precision, arg);
|
||||
} else {
|
||||
n = precision < 0 ?
|
||||
snprintf(&buffer_[offset], size, format, width, arg) :
|
||||
snprintf(&buffer_[offset], size, format, width, precision, arg);
|
||||
}
|
||||
if (n >= 0 && offset + n < buffer_.size()) {
|
||||
buffer_.resize(offset + n);
|
||||
return;
|
||||
}
|
||||
buffer_.resize(n >= 0 ? offset + n + 1 : 2 * buffer_.size());
|
||||
}
|
||||
}
|
||||
|
||||
void fmt::Formatter::Format() {
|
||||
buffer_.reserve(500);
|
||||
const char *start = format_;
|
||||
const char *s = start;
|
||||
for (; *s; ++s) {
|
||||
if (*s != '{') continue;
|
||||
buffer_.insert(buffer_.end(), start, s);
|
||||
++s;
|
||||
|
||||
// Parse argument index.
|
||||
unsigned arg_index = 0;
|
||||
if ('0' <= *s && *s <= '9') {
|
||||
do {
|
||||
arg_index = arg_index * 10 + (*s++ - '0');
|
||||
} while ('0' <= *s && *s <= '9');
|
||||
} else {
|
||||
throw FormatError("missing argument index in format string");
|
||||
}
|
||||
// TODO: check if argument index is correct
|
||||
|
||||
char arg_format[8]; // longest format: %+0*.*ld
|
||||
char *arg_format_ptr = arg_format;
|
||||
*arg_format_ptr++ = '%';
|
||||
|
||||
char type = 0;
|
||||
int width = -1;
|
||||
int precision = -1;
|
||||
if (*s == ':') {
|
||||
++s;
|
||||
if (*s == '+')
|
||||
*arg_format_ptr++ = *s++;
|
||||
if (*s == '0')
|
||||
*arg_format_ptr++ = *s++;
|
||||
|
||||
// Parse width.
|
||||
if ('0' <= *s && *s <= '9') {
|
||||
*arg_format_ptr++ = '*';
|
||||
width = 0;
|
||||
do {
|
||||
width = width * 10 + (*s++ - '0');
|
||||
} while ('0' <= *s && *s <= '9');
|
||||
}
|
||||
|
||||
// Parse precision.
|
||||
if (*s == '.') {
|
||||
*arg_format_ptr++ = '.';
|
||||
*arg_format_ptr++ = '*';
|
||||
++s;
|
||||
precision = 0;
|
||||
if ('0' <= *s && *s <= '9') {
|
||||
do {
|
||||
precision = precision * 10 + (*s++ - '0');
|
||||
} while ('0' <= *s && *s <= '9');
|
||||
} else {
|
||||
// TODO: error
|
||||
}
|
||||
}
|
||||
|
||||
// Parse type.
|
||||
if (*s == 'f' || *s == 'g')
|
||||
type = *s++; // TODO: check if the type matches
|
||||
}
|
||||
|
||||
if (*s++ != '}')
|
||||
throw FormatError("single '{' encountered in format string");
|
||||
start = s;
|
||||
|
||||
// Format argument.
|
||||
Arg &arg = args_[arg_index];
|
||||
switch (arg.type) {
|
||||
case CHAR:
|
||||
if (width == -1 && precision == -1) {
|
||||
buffer_.push_back(arg.int_value);
|
||||
break;
|
||||
}
|
||||
*arg_format_ptr++ = 'c';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.int_value, width, precision);
|
||||
break;
|
||||
case INT:
|
||||
*arg_format_ptr++ = 'd';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.int_value, width, precision);
|
||||
break;
|
||||
case UINT:
|
||||
*arg_format_ptr++ = 'd';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.uint_value, width, precision);
|
||||
break;
|
||||
case LONG:
|
||||
*arg_format_ptr++ = 'l';
|
||||
*arg_format_ptr++ = 'd';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.long_value, width, precision);
|
||||
break;
|
||||
case ULONG:
|
||||
*arg_format_ptr++ = 'l';
|
||||
*arg_format_ptr++ = 'd';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.ulong_value, width, precision);
|
||||
break;
|
||||
case DOUBLE:
|
||||
*arg_format_ptr++ = type ? type : 'g';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.double_value, width, precision);
|
||||
break;
|
||||
case LONG_DOUBLE:
|
||||
*arg_format_ptr++ = 'l';
|
||||
*arg_format_ptr++ = 'g';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.long_double_value, width, precision);
|
||||
break;
|
||||
case STRING:
|
||||
if (width == -1 && precision == -1) {
|
||||
const char *str = arg.string_value;
|
||||
buffer_.insert(buffer_.end(), str, str + std::strlen(str));
|
||||
break;
|
||||
}
|
||||
*arg_format_ptr++ = 's';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.string_value, width, precision);
|
||||
break;
|
||||
case WSTRING:
|
||||
*arg_format_ptr++ = 'l';
|
||||
*arg_format_ptr++ = 's';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.wstring_value, width, precision);
|
||||
break;
|
||||
case POINTER:
|
||||
*arg_format_ptr++ = 'p';
|
||||
*arg_format_ptr = '\0';
|
||||
FormatArg(arg_format, arg.pointer_value, width, precision);
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
buffer_.insert(buffer_.end(), start, s + 1);
|
||||
}
|
||||
|
||||
fmt::ArgFormatter::~ArgFormatter() {
|
||||
if (!formatter_) return;
|
||||
FinishFormatting();
|
||||
}
|
||||
|
||||
247
format.h
Normal file
247
format.h
Normal file
@ -0,0 +1,247 @@
|
||||
/*
|
||||
Small, safe and fast printf-like formatting library for C++
|
||||
Author: Victor Zverovich
|
||||
*/
|
||||
|
||||
#ifndef FORMAT_H_
|
||||
#define FORMAT_H_
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdio>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace format {
|
||||
|
||||
class FormatError : public std::runtime_error {
|
||||
public:
|
||||
FormatError(const std::string &message) : std::runtime_error(message) {}
|
||||
};
|
||||
|
||||
class ArgFormatter;
|
||||
|
||||
template <typename Callback>
|
||||
class ArgFormatterWithCallback;
|
||||
|
||||
// A sprintf-like formatter that automatically allocates enough storage to
|
||||
// fit all the output.
|
||||
class Formatter {
|
||||
private:
|
||||
std::vector<char> buffer_;
|
||||
|
||||
enum Type {
|
||||
CHAR, INT, UINT, LONG, ULONG, DOUBLE, LONG_DOUBLE, STRING, WSTRING, POINTER
|
||||
};
|
||||
|
||||
struct Arg {
|
||||
Type type;
|
||||
union {
|
||||
int int_value;
|
||||
unsigned uint_value;
|
||||
double double_value;
|
||||
long long_value;
|
||||
unsigned long ulong_value;
|
||||
long double long_double_value;
|
||||
const char *string_value;
|
||||
const wchar_t *wstring_value;
|
||||
const void *pointer_value;
|
||||
};
|
||||
|
||||
explicit Arg(char value) : type(CHAR), int_value(value) {}
|
||||
explicit Arg(int value) : type(INT), int_value(value) {}
|
||||
explicit Arg(unsigned value) : type(UINT), uint_value(value) {}
|
||||
explicit Arg(long value) : type(LONG), long_value(value) {}
|
||||
explicit Arg(unsigned long value) : type(ULONG), ulong_value(value) {}
|
||||
explicit Arg(double value) : type(DOUBLE), double_value(value) {}
|
||||
explicit Arg(long double value)
|
||||
: type(LONG_DOUBLE), long_double_value(value) {}
|
||||
explicit Arg(const char *value) : type(STRING), string_value(value) {}
|
||||
explicit Arg(const wchar_t *value) : type(WSTRING), wstring_value(value) {}
|
||||
explicit Arg(const void *value) : type(POINTER), pointer_value(value) {}
|
||||
};
|
||||
|
||||
std::vector<Arg> args_;
|
||||
|
||||
// Pointer to the part of the format string that hasn't been written yet.
|
||||
const char *format_;
|
||||
|
||||
friend class ArgFormatter;
|
||||
|
||||
void Add(const Arg &arg) {
|
||||
if (args_.empty())
|
||||
args_.reserve(10);
|
||||
args_.push_back(arg);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void FormatArg(const char *format, const T &arg, int width, int precision);
|
||||
|
||||
void Format();
|
||||
|
||||
public:
|
||||
Formatter() : format_(0) {}
|
||||
|
||||
ArgFormatter operator()(const char *format);
|
||||
|
||||
template <typename Callback>
|
||||
ArgFormatterWithCallback<Callback> FormatWithCallback(const char *format);
|
||||
|
||||
const char *c_str() const { return &buffer_[0]; }
|
||||
std::size_t size() const { return buffer_.size() - 1; }
|
||||
};
|
||||
|
||||
class ArgFormatter {
|
||||
private:
|
||||
friend class Formatter;
|
||||
|
||||
protected:
|
||||
mutable Formatter *formatter_;
|
||||
|
||||
ArgFormatter(const ArgFormatter& other) : formatter_(other.formatter_) {
|
||||
other.formatter_ = 0;
|
||||
}
|
||||
|
||||
ArgFormatter& operator=(const ArgFormatter& other) {
|
||||
formatter_ = other.formatter_;
|
||||
other.formatter_ = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Formatter *FinishFormatting() const {
|
||||
Formatter *f = formatter_;
|
||||
if (f) {
|
||||
formatter_ = 0;
|
||||
f->Format();
|
||||
}
|
||||
return f;
|
||||
}
|
||||
|
||||
public:
|
||||
explicit ArgFormatter(Formatter &f) : formatter_(&f) {}
|
||||
~ArgFormatter();
|
||||
|
||||
friend const char *c_str(const ArgFormatter &af) {
|
||||
return af.FinishFormatting()->c_str();
|
||||
}
|
||||
|
||||
friend std::string str(const ArgFormatter &af) {
|
||||
return af.FinishFormatting()->c_str();
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(char value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(int value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(unsigned value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(long value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(unsigned long value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(double value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(long double value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(const char *value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
ArgFormatter &operator<<(const void *value) {
|
||||
formatter_->Add(Formatter::Arg(value));
|
||||
return *this;
|
||||
}
|
||||
|
||||
// This method is not implemented intentionally to disallow output of
|
||||
// arbitrary pointers. If you want to output a pointer cast it to void*.
|
||||
template <typename T>
|
||||
ArgFormatter &operator<<(const T *value);
|
||||
};
|
||||
|
||||
template <typename Callback>
|
||||
class ArgFormatterWithCallback : public ArgFormatter {
|
||||
public:
|
||||
explicit ArgFormatterWithCallback(Formatter &f) : ArgFormatter(f) {}
|
||||
|
||||
~ArgFormatterWithCallback() {
|
||||
if (!formatter_) return;
|
||||
Callback callback;
|
||||
callback(*formatter_);
|
||||
}
|
||||
};
|
||||
|
||||
inline ArgFormatter Formatter::operator()(const char *format) {
|
||||
format_ = format;
|
||||
return ArgFormatter(*this);
|
||||
}
|
||||
|
||||
template <typename Callback>
|
||||
ArgFormatterWithCallback<Callback>
|
||||
Formatter::FormatWithCallback(const char *format) {
|
||||
format_ = format;
|
||||
return ArgFormatterWithCallback<Callback>(*this);
|
||||
}
|
||||
|
||||
class Format : public ArgFormatter {
|
||||
private:
|
||||
Formatter formatter_;
|
||||
|
||||
// Do not implement.
|
||||
Format(const Format&);
|
||||
Format& operator=(const Format&);
|
||||
|
||||
public:
|
||||
explicit Format(const char *format) : ArgFormatter(formatter_) {
|
||||
ArgFormatter::operator=(formatter_(format));
|
||||
}
|
||||
|
||||
~Format() {
|
||||
FinishFormatting();
|
||||
}
|
||||
};
|
||||
|
||||
class Print : public ArgFormatter {
|
||||
private:
|
||||
Formatter formatter_;
|
||||
|
||||
// Do not implement.
|
||||
Print(const Print&);
|
||||
Print& operator=(const Print&);
|
||||
|
||||
public:
|
||||
explicit Print(const char *format) : ArgFormatter(formatter_) {
|
||||
ArgFormatter::operator=(formatter_(format));
|
||||
}
|
||||
|
||||
~Print() {
|
||||
FinishFormatting();
|
||||
std::fwrite(formatter_.c_str(), 1, formatter_.size(), stdout);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace fmt = format;
|
||||
|
||||
#endif // FORMAT_H_
|
||||
Loading…
Reference in New Issue
Block a user