mirror of
https://github.com/fmtlib/fmt.git
synced 2024-12-24 21:16:56 +00:00
Move ArgInfo to internal namespace and add ArgList.
This commit is contained in:
Victor Zverovich
parent
8d4535e76c
commit
ea99bfb902
190
format.cc
190
format.cc
@ -331,8 +331,8 @@ int fmt::internal::ParseNonnegativeInt(
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
const typename fmt::BasicWriter<Char>::ArgInfo
|
||||
fmt::BasicWriter<Char>::DUMMY_ARG = {fmt::BasicWriter<Char>::INT, 0};
|
||||
const typename fmt::internal::ArgInfo
|
||||
fmt::BasicWriter<Char>::DUMMY_ARG = {fmt::internal::ArgInfo::INT, 0};
|
||||
|
||||
// Fills the padding around the content and returns the pointer to the
|
||||
// content area.
|
||||
@ -501,15 +501,15 @@ void fmt::BasicWriter<Char>::FormatDouble(T value, const FormatSpec &spec) {
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
fmt::ULongLong fmt::BasicWriter<Char>::GetIntValue(const ArgInfo &arg) {
|
||||
fmt::ULongLong fmt::BasicWriter<Char>::GetIntValue(const Arg &arg) {
|
||||
switch (arg.type) {
|
||||
case INT:
|
||||
case Arg::INT:
|
||||
return arg.int_value;
|
||||
case UINT:
|
||||
case Arg::UINT:
|
||||
return arg.uint_value;
|
||||
case LONG_LONG:
|
||||
case Arg::LONG_LONG:
|
||||
return arg.long_long_value;
|
||||
case ULONG_LONG:
|
||||
case Arg::ULONG_LONG:
|
||||
return arg.ulong_long_value;
|
||||
default:
|
||||
return -1;
|
||||
@ -517,7 +517,24 @@ fmt::ULongLong fmt::BasicWriter<Char>::GetIntValue(const ArgInfo &arg) {
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
inline const typename fmt::BasicWriter<Char>::ArgInfo
|
||||
template <typename StringChar>
|
||||
void fmt::BasicWriter<Char>::FormatString(
|
||||
const Arg::StringValue<StringChar> &str, const FormatSpec &spec) {
|
||||
if (spec.type_ && spec.type_ != 's')
|
||||
internal::ReportUnknownType(spec.type_, "string");
|
||||
const StringChar *s = str.value;
|
||||
std::size_t size = str.size;
|
||||
if (size == 0) {
|
||||
if (!s)
|
||||
throw FormatError("string pointer is null");
|
||||
if (*s)
|
||||
size = std::char_traits<StringChar>::length(s);
|
||||
}
|
||||
FormatString(s, size, spec);
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
inline const typename fmt::BasicWriter<Char>::Arg
|
||||
&fmt::BasicWriter<Char>::FormatParser::ParseArgIndex(const Char *&s) {
|
||||
unsigned arg_index = 0;
|
||||
if (*s < '0' || *s > '9') {
|
||||
@ -539,20 +556,20 @@ inline const typename fmt::BasicWriter<Char>::ArgInfo
|
||||
if (error)
|
||||
report_error_(s, error); // TODO
|
||||
}
|
||||
if (arg_index >= num_args_)
|
||||
if (arg_index >= args_.size())
|
||||
report_error_(s, "argument index is out of range in format");
|
||||
return args_[arg_index];
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
void fmt::BasicWriter<Char>::FormatParser::CheckSign(
|
||||
const Char *&s, const ArgInfo &arg) {
|
||||
const Char *&s, const Arg &arg) {
|
||||
char sign = static_cast<char>(*s);
|
||||
if (arg.type > LAST_NUMERIC_TYPE) {
|
||||
if (arg.type > Arg::LAST_NUMERIC_TYPE) {
|
||||
report_error_(s,
|
||||
fmt::Format("format specifier '{}' requires numeric argument") << sign);
|
||||
}
|
||||
if (arg.type == UINT || arg.type == ULONG_LONG) {
|
||||
if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
|
||||
report_error_(s,
|
||||
fmt::Format("format specifier '{}' requires signed argument") << sign);
|
||||
}
|
||||
@ -615,27 +632,28 @@ unsigned fmt::BasicWriter<Char>::PrintfParser::ParseHeader(
|
||||
spec.width_ = internal::ParseNonnegativeInt(s, error);
|
||||
} else if (*s == '*') {
|
||||
++s;
|
||||
const ArgInfo &arg = HandleArgIndex(UINT_MAX, error);
|
||||
const Arg &arg = HandleArgIndex(UINT_MAX, error);
|
||||
// TODO: use ArgVisitor
|
||||
ULongLong width = 0;
|
||||
switch (arg.type) {
|
||||
case INT:
|
||||
case Arg::INT:
|
||||
width = arg.int_value;
|
||||
if (arg.int_value < 0) {
|
||||
spec.align_ = ALIGN_LEFT;
|
||||
width = 0 - width;
|
||||
}
|
||||
break;
|
||||
case UINT:
|
||||
case Arg::UINT:
|
||||
width = arg.uint_value;
|
||||
break;
|
||||
case LONG_LONG:
|
||||
case Arg::LONG_LONG:
|
||||
width = arg.long_long_value;
|
||||
if (arg.long_long_value < 0) {
|
||||
spec.align_ = ALIGN_LEFT;
|
||||
width = 0 - width;
|
||||
}
|
||||
break;
|
||||
case ULONG_LONG:
|
||||
case Arg::ULONG_LONG:
|
||||
width = arg.ulong_long_value;
|
||||
break;
|
||||
default:
|
||||
@ -652,7 +670,7 @@ unsigned fmt::BasicWriter<Char>::PrintfParser::ParseHeader(
|
||||
|
||||
// TODO: move to a base class that doesn't depend on template argument
|
||||
template <typename Char>
|
||||
const typename fmt::BasicWriter<Char>::ArgInfo
|
||||
const typename fmt::BasicWriter<Char>::Arg
|
||||
&fmt::BasicWriter<Char>::PrintfParser::HandleArgIndex(
|
||||
unsigned arg_index, const char *&error) {
|
||||
if (arg_index != UINT_MAX) {
|
||||
@ -667,7 +685,7 @@ const typename fmt::BasicWriter<Char>::ArgInfo
|
||||
} else if (!error) {
|
||||
error = "cannot switch from manual to automatic argument indexing";
|
||||
}
|
||||
if (arg_index < num_args_)
|
||||
if (arg_index < args_.size())
|
||||
return args_[arg_index];
|
||||
if (!error)
|
||||
error = "argument index is out of range in format";
|
||||
@ -677,9 +695,8 @@ const typename fmt::BasicWriter<Char>::ArgInfo
|
||||
template <typename Char>
|
||||
void fmt::BasicWriter<Char>::PrintfParser::Format(
|
||||
BasicWriter<Char> &writer, BasicStringRef<Char> format,
|
||||
std::size_t num_args, const ArgInfo *args) {
|
||||
const ArgList &args) {
|
||||
const Char *start = format.c_str();
|
||||
num_args_ = num_args;
|
||||
args_ = args;
|
||||
next_arg_index_ = 0;
|
||||
const Char *s = start;
|
||||
@ -718,25 +735,37 @@ void fmt::BasicWriter<Char>::PrintfParser::Format(
|
||||
spec.precision_ = internal::ParseNonnegativeInt(s, error);
|
||||
} else if (*s == '*') {
|
||||
++s;
|
||||
const ArgInfo &arg = HandleArgIndex(UINT_MAX, error);
|
||||
if (arg.type <= LAST_INTEGER_TYPE)
|
||||
const Arg &arg = HandleArgIndex(UINT_MAX, error);
|
||||
if (arg.type <= Arg::LAST_INTEGER_TYPE)
|
||||
spec.precision_ = GetIntValue(arg);
|
||||
else if (!error)
|
||||
error = "precision is not integer";
|
||||
}
|
||||
}
|
||||
|
||||
const ArgInfo &arg = HandleArgIndex(arg_index, error);
|
||||
const Arg &arg = HandleArgIndex(arg_index, error);
|
||||
if (spec.hash_flag() && GetIntValue(arg) == 0)
|
||||
spec.flags_ &= ~HASH_FLAG;
|
||||
if (spec.fill_ == '0') {
|
||||
if (arg.type <= LAST_NUMERIC_TYPE)
|
||||
if (arg.type <= Arg::LAST_NUMERIC_TYPE)
|
||||
spec.align_ = ALIGN_NUMERIC;
|
||||
else
|
||||
spec.fill_ = ' '; // Ignore '0' flag for non-numeric types.
|
||||
}
|
||||
|
||||
// TODO: parse length
|
||||
// Parse length.
|
||||
switch (*s) {
|
||||
case 'h':
|
||||
// TODO: convert to short
|
||||
case 'l':
|
||||
case 'j':
|
||||
case 'z':
|
||||
case 't':
|
||||
case 'L':
|
||||
// TODO: handle length
|
||||
++s;
|
||||
break;
|
||||
}
|
||||
|
||||
// Parse type.
|
||||
if (!*s)
|
||||
@ -749,25 +778,25 @@ void fmt::BasicWriter<Char>::PrintfParser::Format(
|
||||
|
||||
// Format argument.
|
||||
switch (arg.type) {
|
||||
case INT:
|
||||
case Arg::INT:
|
||||
writer.FormatInt(arg.int_value, spec);
|
||||
break;
|
||||
case UINT:
|
||||
case Arg::UINT:
|
||||
writer.FormatInt(arg.uint_value, spec);
|
||||
break;
|
||||
case LONG_LONG:
|
||||
case Arg::LONG_LONG:
|
||||
writer.FormatInt(arg.long_long_value, spec);
|
||||
break;
|
||||
case ULONG_LONG:
|
||||
case Arg::ULONG_LONG:
|
||||
writer.FormatInt(arg.ulong_long_value, spec);
|
||||
break;
|
||||
case DOUBLE:
|
||||
case Arg::DOUBLE:
|
||||
writer.FormatDouble(arg.double_value, spec);
|
||||
break;
|
||||
case LONG_DOUBLE:
|
||||
case Arg::LONG_DOUBLE:
|
||||
writer.FormatDouble(arg.long_double_value, spec);
|
||||
break;
|
||||
case CHAR: {
|
||||
case Arg::CHAR: {
|
||||
if (spec.type_ && spec.type_ != 'c')
|
||||
internal::ReportUnknownType(spec.type_, "char");
|
||||
typedef typename BasicWriter<Char>::CharPtr CharPtr;
|
||||
@ -789,31 +818,23 @@ void fmt::BasicWriter<Char>::PrintfParser::Format(
|
||||
*out = static_cast<Char>(arg.int_value);
|
||||
break;
|
||||
}
|
||||
case STRING: {
|
||||
if (spec.type_ && spec.type_ != 's')
|
||||
internal::ReportUnknownType(spec.type_, "string");
|
||||
const Char *str = arg.string.value;
|
||||
std::size_t size = arg.string.size;
|
||||
if (size == 0) {
|
||||
if (!str)
|
||||
throw FormatError("string pointer is null");
|
||||
if (*str)
|
||||
size = std::char_traits<Char>::length(str);
|
||||
}
|
||||
writer.FormatString(str, size, spec);
|
||||
case Arg::STRING:
|
||||
writer.FormatString(arg.string, spec);
|
||||
break;
|
||||
}
|
||||
case POINTER:
|
||||
case Arg::WSTRING:
|
||||
writer.FormatString(arg.wstring, spec);
|
||||
break;
|
||||
case Arg::POINTER:
|
||||
if (spec.type_ && spec.type_ != 'p')
|
||||
internal::ReportUnknownType(spec.type_, "pointer");
|
||||
spec.flags_= HASH_FLAG;
|
||||
spec.type_ = 'x';
|
||||
writer.FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
|
||||
break;
|
||||
case CUSTOM:
|
||||
case Arg::CUSTOM:
|
||||
if (spec.type_)
|
||||
internal::ReportUnknownType(spec.type_, "object");
|
||||
arg.custom.format(writer, arg.custom.value, spec);
|
||||
arg.custom.format(&writer, arg.custom.value, spec);
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
@ -826,10 +847,9 @@ void fmt::BasicWriter<Char>::PrintfParser::Format(
|
||||
template <typename Char>
|
||||
void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
BasicWriter<Char> &writer, BasicStringRef<Char> format,
|
||||
std::size_t num_args, const ArgInfo *args) {
|
||||
const ArgList &args) {
|
||||
const char *error = 0;
|
||||
const Char *start = format.c_str();
|
||||
num_args_ = num_args;
|
||||
args_ = args;
|
||||
next_arg_index_ = 0;
|
||||
const Char *s = start;
|
||||
@ -846,7 +866,7 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
report_error_.num_open_braces = 1;
|
||||
writer.buffer_.append(start, s - 1);
|
||||
|
||||
const ArgInfo &arg = ParseArgIndex(s);
|
||||
const Arg &arg = ParseArgIndex(s);
|
||||
|
||||
FormatSpec spec;
|
||||
if (*s == ':') {
|
||||
@ -879,7 +899,7 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
s += 2;
|
||||
spec.fill_ = c;
|
||||
} else ++s;
|
||||
if (spec.align_ == ALIGN_NUMERIC && arg.type > LAST_NUMERIC_TYPE)
|
||||
if (spec.align_ == ALIGN_NUMERIC && arg.type > Arg::LAST_NUMERIC_TYPE)
|
||||
report_error_(s, "format specifier '=' requires numeric argument");
|
||||
break;
|
||||
}
|
||||
@ -902,7 +922,7 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
}
|
||||
|
||||
if (*s == '#') {
|
||||
if (arg.type > LAST_NUMERIC_TYPE)
|
||||
if (arg.type > Arg::LAST_NUMERIC_TYPE)
|
||||
report_error_(s, "format specifier '#' requires numeric argument");
|
||||
spec.flags_ |= HASH_FLAG;
|
||||
++s;
|
||||
@ -911,7 +931,7 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
// Parse width and zero flag.
|
||||
if ('0' <= *s && *s <= '9') {
|
||||
if (*s == '0') {
|
||||
if (arg.type > LAST_NUMERIC_TYPE)
|
||||
if (arg.type > Arg::LAST_NUMERIC_TYPE)
|
||||
report_error_(s, "format specifier '0' requires numeric argument");
|
||||
spec.align_ = ALIGN_NUMERIC;
|
||||
spec.fill_ = '0';
|
||||
@ -934,23 +954,23 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
} else if (*s == '{') {
|
||||
++s;
|
||||
++report_error_.num_open_braces;
|
||||
const ArgInfo &precision_arg = ParseArgIndex(s);
|
||||
const Arg &precision_arg = ParseArgIndex(s);
|
||||
ULongLong value = 0;
|
||||
switch (precision_arg.type) {
|
||||
case INT:
|
||||
case Arg::INT:
|
||||
if (precision_arg.int_value < 0)
|
||||
report_error_(s, "negative precision in format");
|
||||
value = precision_arg.int_value;
|
||||
break;
|
||||
case UINT:
|
||||
case Arg::UINT:
|
||||
value = precision_arg.uint_value;
|
||||
break;
|
||||
case LONG_LONG:
|
||||
case Arg::LONG_LONG:
|
||||
if (precision_arg.long_long_value < 0)
|
||||
report_error_(s, "negative precision in format");
|
||||
value = precision_arg.long_long_value;
|
||||
break;
|
||||
case ULONG_LONG:
|
||||
case Arg::ULONG_LONG:
|
||||
value = precision_arg.ulong_long_value;
|
||||
break;
|
||||
default:
|
||||
@ -965,7 +985,7 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
} else {
|
||||
report_error_(s, "missing precision in format");
|
||||
}
|
||||
if (arg.type != DOUBLE && arg.type != LONG_DOUBLE) {
|
||||
if (arg.type != Arg::DOUBLE && arg.type != Arg::LONG_DOUBLE) {
|
||||
report_error_(s,
|
||||
"precision specifier requires floating-point argument");
|
||||
}
|
||||
@ -982,25 +1002,25 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
|
||||
// Format argument.
|
||||
switch (arg.type) {
|
||||
case INT:
|
||||
case Arg::INT:
|
||||
writer.FormatInt(arg.int_value, spec);
|
||||
break;
|
||||
case UINT:
|
||||
case Arg::UINT:
|
||||
writer.FormatInt(arg.uint_value, spec);
|
||||
break;
|
||||
case LONG_LONG:
|
||||
case Arg::LONG_LONG:
|
||||
writer.FormatInt(arg.long_long_value, spec);
|
||||
break;
|
||||
case ULONG_LONG:
|
||||
case Arg::ULONG_LONG:
|
||||
writer.FormatInt(arg.ulong_long_value, spec);
|
||||
break;
|
||||
case DOUBLE:
|
||||
case Arg::DOUBLE:
|
||||
writer.FormatDouble(arg.double_value, spec);
|
||||
break;
|
||||
case LONG_DOUBLE:
|
||||
case Arg::LONG_DOUBLE:
|
||||
writer.FormatDouble(arg.long_double_value, spec);
|
||||
break;
|
||||
case CHAR: {
|
||||
case Arg::CHAR: {
|
||||
if (spec.type_ && spec.type_ != 'c')
|
||||
internal::ReportUnknownType(spec.type_, "char");
|
||||
typedef typename BasicWriter<Char>::CharPtr CharPtr;
|
||||
@ -1022,31 +1042,23 @@ void fmt::BasicWriter<Char>::FormatParser::Format(
|
||||
*out = static_cast<Char>(arg.int_value);
|
||||
break;
|
||||
}
|
||||
case STRING: {
|
||||
if (spec.type_ && spec.type_ != 's')
|
||||
internal::ReportUnknownType(spec.type_, "string");
|
||||
const Char *str = arg.string.value;
|
||||
std::size_t size = arg.string.size;
|
||||
if (size == 0) {
|
||||
if (!str)
|
||||
throw FormatError("string pointer is null");
|
||||
if (*str)
|
||||
size = std::char_traits<Char>::length(str);
|
||||
}
|
||||
writer.FormatString(str, size, spec);
|
||||
case Arg::STRING:
|
||||
writer.FormatString(arg.string, spec);
|
||||
break;
|
||||
}
|
||||
case POINTER:
|
||||
case Arg::WSTRING:
|
||||
writer.FormatString(arg.wstring, spec);
|
||||
break;
|
||||
case Arg::POINTER:
|
||||
if (spec.type_ && spec.type_ != 'p')
|
||||
internal::ReportUnknownType(spec.type_, "pointer");
|
||||
spec.flags_= HASH_FLAG;
|
||||
spec.type_ = 'x';
|
||||
writer.FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
|
||||
break;
|
||||
case CUSTOM:
|
||||
case Arg::CUSTOM:
|
||||
if (spec.type_)
|
||||
internal::ReportUnknownType(spec.type_, "object");
|
||||
arg.custom.format(writer, arg.custom.value, spec);
|
||||
arg.custom.format(&writer, arg.custom.value, spec);
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
@ -1098,12 +1110,10 @@ template fmt::BasicWriter<char>::CharPtr
|
||||
unsigned total_size, std::size_t content_size, wchar_t fill);
|
||||
|
||||
template void fmt::BasicWriter<char>::FormatParser::Format(
|
||||
BasicWriter<char> &writer, BasicStringRef<char> format,
|
||||
std::size_t num_args, const ArgInfo *args);
|
||||
BasicWriter<char> &writer, BasicStringRef<char> format, const ArgList &args);
|
||||
|
||||
template void fmt::BasicWriter<char>::PrintfParser::Format(
|
||||
BasicWriter<char> &writer, BasicStringRef<char> format,
|
||||
std::size_t num_args, const ArgInfo *args);
|
||||
BasicWriter<char> &writer, BasicStringRef<char> format, const ArgList &args);
|
||||
|
||||
// Explicit instantiations for wchar_t.
|
||||
|
||||
@ -1113,11 +1123,11 @@ template fmt::BasicWriter<wchar_t>::CharPtr
|
||||
|
||||
template void fmt::BasicWriter<wchar_t>::FormatParser::Format(
|
||||
BasicWriter<wchar_t> &writer, BasicStringRef<wchar_t> format,
|
||||
std::size_t num_args, const ArgInfo *args);
|
||||
const ArgList &args);
|
||||
|
||||
template void fmt::BasicWriter<wchar_t>::PrintfParser::Format(
|
||||
BasicWriter<wchar_t> &writer, BasicStringRef<wchar_t> format,
|
||||
std::size_t num_args, const ArgInfo *args);
|
||||
const ArgList &args);
|
||||
|
||||
#if _MSC_VER
|
||||
# pragma warning(pop)
|
||||
|
||||
257
format.h
257
format.h
@ -477,8 +477,7 @@ void FormatDecimal(Char *buffer, UInt value, unsigned num_digits) {
|
||||
}
|
||||
|
||||
template <typename Char, typename T>
|
||||
void FormatCustomArg(
|
||||
BasicWriter<Char> &w, const void *arg, const FormatSpec &spec);
|
||||
void FormatCustomArg(void *writer, const void *arg, const FormatSpec &spec);
|
||||
|
||||
#ifdef _WIN32
|
||||
// A converter from UTF-8 to UTF-16.
|
||||
@ -563,6 +562,46 @@ template <>
|
||||
struct NonZero<0> {
|
||||
enum { VALUE = 1 };
|
||||
};
|
||||
|
||||
// Information about a format argument. It is a POD type to allow
|
||||
// storage in internal::Array.
|
||||
struct ArgInfo {
|
||||
enum Type {
|
||||
// Integer types should go first,
|
||||
INT, UINT, LONG_LONG, ULONG_LONG, LAST_INTEGER_TYPE = ULONG_LONG,
|
||||
// followed by floating-point types.
|
||||
DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
|
||||
CHAR, STRING, WSTRING, POINTER, CUSTOM
|
||||
};
|
||||
Type type;
|
||||
|
||||
template <typename Char>
|
||||
struct StringValue {
|
||||
const Char *value;
|
||||
std::size_t size;
|
||||
};
|
||||
|
||||
typedef void (*FormatFunc)(
|
||||
void *writer, const void *arg, const FormatSpec &spec);
|
||||
|
||||
struct CustomValue {
|
||||
const void *value;
|
||||
FormatFunc format;
|
||||
};
|
||||
|
||||
union {
|
||||
int int_value;
|
||||
unsigned uint_value;
|
||||
double double_value;
|
||||
LongLong long_long_value;
|
||||
ULongLong ulong_long_value;
|
||||
long double long_double_value;
|
||||
const void *pointer_value;
|
||||
StringValue<char> string;
|
||||
StringValue<wchar_t> wstring;
|
||||
CustomValue custom;
|
||||
};
|
||||
};
|
||||
} // namespace internal
|
||||
|
||||
/**
|
||||
@ -806,6 +845,23 @@ inline StrFormatSpec<wchar_t> pad(
|
||||
return StrFormatSpec<wchar_t>(str, width, fill);
|
||||
}
|
||||
|
||||
class ArgList {
|
||||
private:
|
||||
const internal::ArgInfo *args_;
|
||||
std::size_t size_;
|
||||
|
||||
public:
|
||||
ArgList() : size_(0) {}
|
||||
ArgList(const internal::ArgInfo *args, std::size_t size)
|
||||
: args_(args), size_(size) {}
|
||||
|
||||
std::size_t size() const { return size_; }
|
||||
|
||||
const internal::ArgInfo &operator[](std::size_t index) const {
|
||||
return args_[index];
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
\rst
|
||||
This template provides operations for formatting and writing data into
|
||||
@ -850,6 +906,10 @@ class BasicWriter {
|
||||
|
||||
typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
|
||||
|
||||
typedef internal::ArgInfo Arg;
|
||||
|
||||
static const Arg DUMMY_ARG;
|
||||
|
||||
#if _SECURE_SCL
|
||||
static Char *GetBase(CharPtr p) { return p.base(); }
|
||||
#else
|
||||
@ -893,53 +953,17 @@ class BasicWriter {
|
||||
CharPtr FormatString(
|
||||
const StringChar *s, std::size_t size, const AlignSpec &spec);
|
||||
|
||||
// This method is private to disallow writing a wide string to a
|
||||
template <typename StringChar>
|
||||
void FormatString(
|
||||
const Arg::StringValue<StringChar> &str, const FormatSpec &spec);
|
||||
|
||||
// This method is private to disallow writing a wide string to a
|
||||
// char stream and vice versa. If you want to print a wide string
|
||||
// as a pointer as std::ostream does, cast it to const void*.
|
||||
// Do not implement!
|
||||
void operator<<(typename internal::CharTraits<Char>::UnsupportedStrType);
|
||||
|
||||
enum Type {
|
||||
// Integer types should go first,
|
||||
INT, UINT, LONG_LONG, ULONG_LONG, LAST_INTEGER_TYPE = ULONG_LONG,
|
||||
// followed by floating-point types.
|
||||
DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
|
||||
CHAR, STRING, WSTRING, POINTER, CUSTOM
|
||||
};
|
||||
|
||||
struct StringValue {
|
||||
const Char *value;
|
||||
std::size_t size;
|
||||
};
|
||||
|
||||
typedef void (*FormatFunc)(
|
||||
BasicWriter<Char> &w, const void *arg, const FormatSpec &spec);
|
||||
|
||||
struct CustomValue {
|
||||
const void *value;
|
||||
FormatFunc format;
|
||||
};
|
||||
|
||||
// Information about a format argument. It is a POD type to allow
|
||||
// storage in internal::Array.
|
||||
struct ArgInfo {
|
||||
Type type;
|
||||
union {
|
||||
int int_value;
|
||||
unsigned uint_value;
|
||||
double double_value;
|
||||
LongLong long_long_value;
|
||||
ULongLong ulong_long_value;
|
||||
long double long_double_value;
|
||||
const void *pointer_value;
|
||||
StringValue string;
|
||||
CustomValue custom;
|
||||
};
|
||||
};
|
||||
|
||||
static const ArgInfo DUMMY_ARG;
|
||||
|
||||
static ULongLong GetIntValue(const ArgInfo &arg);
|
||||
static ULongLong GetIntValue(const Arg &arg);
|
||||
|
||||
// An argument action that does nothing.
|
||||
struct NullArgAction {
|
||||
@ -948,7 +972,7 @@ class BasicWriter {
|
||||
|
||||
// A wrapper around a format argument.
|
||||
template <typename Action = NullArgAction>
|
||||
class BasicArg : public Action, public ArgInfo {
|
||||
class BasicArg : public Action, public Arg {
|
||||
private:
|
||||
// This method is private to disallow formatting of arbitrary pointers.
|
||||
// If you want to output a pointer cast it to const void*. Do not implement!
|
||||
@ -961,83 +985,96 @@ class BasicWriter {
|
||||
BasicArg(T *value);
|
||||
|
||||
public:
|
||||
using ArgInfo::type;
|
||||
using Arg::type;
|
||||
|
||||
BasicArg() {}
|
||||
BasicArg(short value) { type = INT; this->int_value = value; }
|
||||
BasicArg(unsigned short value) { type = UINT; this->int_value = value; }
|
||||
BasicArg(int value) { type = INT; this->int_value = value; }
|
||||
BasicArg(unsigned value) { type = UINT; this->uint_value = value; }
|
||||
// TODO: unsigned char & signed char
|
||||
BasicArg(short value) { type = Arg::INT; Arg::int_value = value; }
|
||||
BasicArg(unsigned short value) {
|
||||
type = Arg::UINT;
|
||||
Arg::uint_value = value;
|
||||
}
|
||||
BasicArg(int value) { type = Arg::INT; Arg::int_value = value; }
|
||||
BasicArg(unsigned value) { type = Arg::UINT; Arg::uint_value = value; }
|
||||
BasicArg(long value) {
|
||||
if (sizeof(long) == sizeof(int)) {
|
||||
type = INT;
|
||||
this->int_value = static_cast<int>(value);
|
||||
type = Arg::INT;
|
||||
Arg::int_value = static_cast<int>(value);
|
||||
} else {
|
||||
type = LONG_LONG;
|
||||
this->long_long_value = value;
|
||||
type = Arg::LONG_LONG;
|
||||
Arg::long_long_value = value;
|
||||
}
|
||||
}
|
||||
BasicArg(unsigned long value) {
|
||||
if (sizeof(unsigned long) == sizeof(unsigned)) {
|
||||
type = UINT;
|
||||
this->uint_value = static_cast<unsigned>(value);
|
||||
type = Arg::UINT;
|
||||
Arg::uint_value = static_cast<unsigned>(value);
|
||||
} else {
|
||||
type = ULONG_LONG;
|
||||
this->ulong_long_value = value;
|
||||
type = Arg::ULONG_LONG;
|
||||
Arg::ulong_long_value = value;
|
||||
}
|
||||
}
|
||||
BasicArg(LongLong value) {
|
||||
type = LONG_LONG;
|
||||
this->long_long_value = value;
|
||||
type = Arg::LONG_LONG;
|
||||
Arg::long_long_value = value;
|
||||
}
|
||||
BasicArg(ULongLong value) {
|
||||
type = ULONG_LONG;
|
||||
this->ulong_long_value = value;
|
||||
type = Arg::ULONG_LONG;
|
||||
Arg::ulong_long_value = value;
|
||||
}
|
||||
BasicArg(float value) { type = DOUBLE; this->double_value = value; }
|
||||
BasicArg(double value) { type = DOUBLE; this->double_value = value; }
|
||||
BasicArg(float value) { type = Arg::DOUBLE; Arg::double_value = value; }
|
||||
BasicArg(double value) { type = Arg::DOUBLE; Arg::double_value = value; }
|
||||
BasicArg(long double value) {
|
||||
type = LONG_DOUBLE;
|
||||
this->long_double_value = value;
|
||||
type = Arg::LONG_DOUBLE;
|
||||
Arg::long_double_value = value;
|
||||
}
|
||||
BasicArg(char value) { type = CHAR; this->int_value = value; }
|
||||
BasicArg(char value) { type = Arg::CHAR; Arg::int_value = value; }
|
||||
BasicArg(wchar_t value) {
|
||||
type = CHAR;
|
||||
this->int_value = internal::CharTraits<Char>::ConvertChar(value);
|
||||
type = Arg::CHAR;
|
||||
Arg::int_value = internal::CharTraits<Char>::ConvertChar(value);
|
||||
}
|
||||
|
||||
BasicArg(const Char *value) {
|
||||
type = STRING;
|
||||
this->string.value = value;
|
||||
this->string.size = 0;
|
||||
BasicArg(const char *value) {
|
||||
type = Arg::STRING;
|
||||
Arg::string.value = value;
|
||||
Arg::string.size = 0;
|
||||
}
|
||||
|
||||
BasicArg(const wchar_t *value) {
|
||||
type = Arg::WSTRING;
|
||||
Arg::wstring.value = value;
|
||||
Arg::wstring.size = 0;
|
||||
}
|
||||
|
||||
BasicArg(Char *value) {
|
||||
type = STRING;
|
||||
this->string.value = value;
|
||||
this->string.size = 0;
|
||||
type = Arg::STRING;
|
||||
Arg::string.value = value;
|
||||
Arg::string.size = 0;
|
||||
}
|
||||
|
||||
BasicArg(const void *value) { type = POINTER; this->pointer_value = value; }
|
||||
BasicArg(void *value) { type = POINTER; this->pointer_value = value; }
|
||||
BasicArg(const void *value) {
|
||||
type = Arg::POINTER;
|
||||
Arg::pointer_value = value;
|
||||
}
|
||||
BasicArg(void *value) { type = Arg::POINTER; Arg::pointer_value = value; }
|
||||
|
||||
BasicArg(const std::basic_string<Char> &value) {
|
||||
type = STRING;
|
||||
this->string.value = value.c_str();
|
||||
this->string.size = value.size();
|
||||
type = Arg::STRING;
|
||||
Arg::string.value = value.c_str();
|
||||
Arg::string.size = value.size();
|
||||
}
|
||||
|
||||
BasicArg(BasicStringRef<Char> value) {
|
||||
type = STRING;
|
||||
this->string.value = value.c_str();
|
||||
this->string.size = value.size();
|
||||
type = Arg::STRING;
|
||||
Arg::string.value = value.c_str();
|
||||
Arg::string.size = value.size();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
BasicArg(const T &value) {
|
||||
type = CUSTOM;
|
||||
this->custom.value = &value;
|
||||
this->custom.format = &internal::FormatCustomArg<Char, T>;
|
||||
type = Arg::CUSTOM;
|
||||
Arg::custom.value = &value;
|
||||
Arg::custom.format = &internal::FormatCustomArg<Char, T>;
|
||||
}
|
||||
|
||||
// The destructor is declared noexcept(false) because the action may throw
|
||||
@ -1048,31 +1085,27 @@ class BasicWriter {
|
||||
}
|
||||
};
|
||||
|
||||
typedef BasicArg<> Arg;
|
||||
|
||||
// Format string parser.
|
||||
class FormatParser {
|
||||
private:
|
||||
std::size_t num_args_;
|
||||
const ArgInfo *args_;
|
||||
ArgList args_;
|
||||
int next_arg_index_;
|
||||
fmt::internal::FormatErrorReporter<Char> report_error_;
|
||||
|
||||
// Parses argument index and returns an argument with this index.
|
||||
const ArgInfo &ParseArgIndex(const Char *&s);
|
||||
const Arg &ParseArgIndex(const Char *&s);
|
||||
|
||||
void CheckSign(const Char *&s, const ArgInfo &arg);
|
||||
void CheckSign(const Char *&s, const Arg &arg);
|
||||
|
||||
public:
|
||||
void Format(BasicWriter<Char> &writer,
|
||||
BasicStringRef<Char> format, std::size_t num_args, const ArgInfo *args);
|
||||
BasicStringRef<Char> format, const ArgList &args);
|
||||
};
|
||||
|
||||
// Printf format string parser.
|
||||
class PrintfParser {
|
||||
private:
|
||||
std::size_t num_args_;
|
||||
const ArgInfo *args_;
|
||||
ArgList args_;
|
||||
int next_arg_index_;
|
||||
|
||||
void ParseFlags(FormatSpec &spec, const Char *&s);
|
||||
@ -1081,11 +1114,11 @@ class BasicWriter {
|
||||
// argument index.
|
||||
unsigned ParseHeader(const Char *&s, FormatSpec &spec, const char *&error);
|
||||
|
||||
const ArgInfo &HandleArgIndex(unsigned arg_index, const char *&error);
|
||||
const Arg &HandleArgIndex(unsigned arg_index, const char *&error);
|
||||
|
||||
public:
|
||||
void Format(BasicWriter<Char> &writer,
|
||||
BasicStringRef<Char> format, std::size_t num_args, const ArgInfo *args);
|
||||
BasicStringRef<Char> format, const ArgList &args);
|
||||
};
|
||||
|
||||
public:
|
||||
@ -1140,14 +1173,12 @@ class BasicWriter {
|
||||
return std::basic_string<Char>(&buffer_[0], buffer_.size());
|
||||
}
|
||||
|
||||
inline void VFormat(BasicStringRef<Char> format,
|
||||
std::size_t num_args, const ArgInfo *args) {
|
||||
FormatParser().Format(*this, format, num_args, args);
|
||||
inline void format(BasicStringRef<Char> format, const ArgList &args) {
|
||||
FormatParser().Format(*this, format, args);
|
||||
}
|
||||
|
||||
inline void vprintf(BasicStringRef<Char> format,
|
||||
std::size_t num_args, const ArgInfo *args) {
|
||||
PrintfParser().Format(*this, format, num_args, args);
|
||||
inline void printf(BasicStringRef<Char> format, const ArgList &args) {
|
||||
PrintfParser().Format(*this, format, args);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1207,14 +1238,14 @@ class BasicWriter {
|
||||
*/
|
||||
template<typename... Args>
|
||||
void Format(BasicStringRef<Char> format, const Args & ... args) {
|
||||
Arg arg_array[] = {args...};
|
||||
VFormat(format, sizeof...(Args), arg_array);
|
||||
BasicArg<> arg_array[] = {args...};
|
||||
this->format(format, ArgList(arg_array, sizeof...(Args)));
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
void printf(BasicStringRef<Char> format, const Args & ... args) {
|
||||
Arg arg_array[internal::NonZero<sizeof...(Args)>::VALUE] = {args...};
|
||||
vprintf(format, sizeof...(Args), arg_array);
|
||||
BasicArg<> arg_array[internal::NonZero<sizeof...(Args)>::VALUE] = {args...};
|
||||
this->printf(format, ArgList(arg_array, sizeof...(Args)));
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1486,9 +1517,9 @@ void Format(BasicWriter<Char> &w, const FormatSpec &spec, const T &value) {
|
||||
namespace internal {
|
||||
// Formats an argument of a custom type, such as a user-defined class.
|
||||
template <typename Char, typename T>
|
||||
void FormatCustomArg(
|
||||
BasicWriter<Char> &w, const void *arg, const FormatSpec &spec) {
|
||||
Format(w, spec, *static_cast<const T*>(arg));
|
||||
void FormatCustomArg(void *writer, const void *arg, const FormatSpec &spec) {
|
||||
Format(*static_cast<BasicWriter<Char>*>(writer),
|
||||
spec, *static_cast<const T*>(arg));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1527,7 +1558,7 @@ class BasicFormatter {
|
||||
}
|
||||
};
|
||||
|
||||
typedef typename BasicWriter<Char>::ArgInfo ArgInfo;
|
||||
typedef typename internal::ArgInfo ArgInfo;
|
||||
typedef typename BasicWriter<Char>::template BasicArg<ArgAction> Arg;
|
||||
|
||||
enum { NUM_INLINE_ARGS = 10 };
|
||||
@ -1554,7 +1585,7 @@ class BasicFormatter {
|
||||
if (!format_) return;
|
||||
const Char *format = format_;
|
||||
format_ = 0;
|
||||
writer_->VFormat(format, args_.size(), &args_[0]);
|
||||
writer_->format(format, ArgList(&args_[0], args_.size()));
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user