Initial import

This commit is contained in:
Victor Zverovich 2012-12-07 08:31:09 -08:00
parent ec27d5d8a1
commit b076df4f80
3 changed files with 431 additions and 0 deletions

184
format.cc Normal file
View 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
View 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_