Skip to content

/ cxx17_printf

Permalink
master
Switch branches/tags

cxx17_printf/Printf.h

Go to file
 
 
Cannot retrieve contributors at this time
900 lines (779 sloc) 25.8 KB
Raw Blame
#ifndef PRINTF_20160922_H_
#define PRINTF_20160922_H_
#include "Formatters.h"
#include <algorithm>
#include <cassert>
#include <cstring>
#include <stdexcept>
#include <string>
#include <tuple>
//#define CXX17_PRINTF_EXTENSIONS
#ifdef __GNUC__
#define LIKELY(expr) __builtin_expect(!!(expr), 1)
#define UNLIKELY(expr) __builtin_expect(!!(expr), 0)
#define NO_INLINE __attribute__((noinline))
#else
#define LIKELY(expr) (expr)
#define UNLIKELY(expr) (expr)
#define NO_INLINE
#endif
namespace cxx17 {
struct format_error : std::runtime_error {
format_error(const char *what_arg) : std::runtime_error(what_arg) {
};
};
namespace detail {
enum class Modifiers : uint8_t {
None,
Char,
Short,
Long,
LongLong,
LongDouble,
IntMaxT,
SizeT,
PtrDiffT
};
struct Flags {
uint8_t justify : 1;
uint8_t sign : 1;
uint8_t space : 1;
uint8_t prefix : 1;
uint8_t padding : 1;
uint8_t reserved : 3;
};
static_assert(sizeof(Flags) == sizeof(uint8_t));
[[noreturn]]
// NOTE(eteran): exception throwing is considered the "cold path"
// so let's never inline it to keep the hot path small
void NO_INLINE ThrowError(const char *what) {
throw format_error(what);
}
template <bool Upper, size_t Divisor, class T, size_t N>
std::tuple<const char *, size_t> format(char (&buf)[N], T d, int width, Flags flags) {
if constexpr (Divisor == 10) {
static constexpr const char digit_pairs[201] = {"00010203040506070809"
"10111213141516171819"
"20212223242526272829"
"30313233343536373839"
"40414243444546474849"
"50515253545556575859"
"60616263646566676869"
"70717273747576777879"
"80818283848586878889"
"90919293949596979899"};
char *it = &buf[N - 2];
if constexpr (std::is_signed<T>::value) {
if (d >= 0) {
int div = d / 100;
while (div) {
std::memcpy(it, &digit_pairs[2 * (d - div * 100)], 2);
d = div;
it -= 2;
div = d / 100;
}
std::memcpy(it, &digit_pairs[2 * d], 2);
if (d < 10) {
it++;
}
if (flags.space) {
if (flags.padding) {
while (&buf[N] - it < width - 1) {
*--it = '0';
}
}
*--it = ' ';
} else if (flags.sign) {
if (flags.padding) {
while (&buf[N] - it < width - 1) {
*--it = '0';
}
}
*--it = '+';
} else {
if (flags.padding) {
while (&buf[N] - it < width) {
*--it = '0';
}
}
}
} else {
int div = d / 100;
while (div) {
std::memcpy(it, &digit_pairs[-2 * (d - div * 100)], 2);
d = div;
it -= 2;
div = d / 100;
}
std::memcpy(it, &digit_pairs[-2 * d], 2);
if (d <= -10) {
it--;
}
if (flags.padding) {
while (&buf[N] - it < width) {
*--it = '0';
}
}
*it = '-';
}
} else {
if (d >= 0) {
int div = d / 100;
while (div) {
std::memcpy(it, &digit_pairs[2 * (d - div * 100)], 2);
d = div;
it -= 2;
div = d / 100;
}
std::memcpy(it, &digit_pairs[2 * d], 2);
if (d < 10) {
it++;
}
if (flags.space) {
if (flags.padding) {
while (&buf[N] - it < width - 1) {
*--it = '0';
}
}
*--it = ' ';
} else if (flags.sign) {
if (flags.padding) {
while (&buf[N] - it < width - 1) {
*--it = '0';
}
}
*--it = '+';
} else {
if (flags.padding) {
while (&buf[N] - it < width) {
*--it = '0';
}
}
}
}
}
return std::make_tuple(it, &buf[N] - it);
} else if constexpr (Divisor == 16) {
[[maybe_unused]] static constexpr const char xdigit_pairs_l[513] = {"000102030405060708090a0b0c0d0e0f"
"101112131415161718191a1b1c1d1e1f"
"202122232425262728292a2b2c2d2e2f"
"303132333435363738393a3b3c3d3e3f"
"404142434445464748494a4b4c4d4e4f"
"505152535455565758595a5b5c5d5e5f"
"606162636465666768696a6b6c6d6e6f"
"707172737475767778797a7b7c7d7e7f"
"808182838485868788898a8b8c8d8e8f"
"909192939495969798999a9b9c9d9e9f"
"a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
"e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"};
[[maybe_unused]] static constexpr const char xdigit_pairs_u[513] = {"000102030405060708090A0B0C0D0E0F"
"101112131415161718191A1B1C1D1E1F"
"202122232425262728292A2B2C2D2E2F"
"303132333435363738393A3B3C3D3E3F"
"404142434445464748494A4B4C4D4E4F"
"505152535455565758595A5B5C5D5E5F"
"606162636465666768696A6B6C6D6E6F"
"707172737475767778797A7B7C7D7E7F"
"808182838485868788898A8B8C8D8E8F"
"909192939495969798999A9B9C9D9E9F"
"A0A1A2A3A4A5A6A7A8A9AAABACADAEAF"
"B0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"
"C0C1C2C3C4C5C6C7C8C9CACBCCCDCECF"
"D0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF"
"E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF"
"F0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF"};
// NOTE(eteran): we include the x/X, here as an easy way to put the
// upper/lower case prefix for hex numbers
[[maybe_unused]] static constexpr const char alphabet_l[] = "0123456789abcdefx";
[[maybe_unused]] static constexpr const char alphabet_u[] = "0123456789ABCDEFX";
typename std::make_unsigned<T>::type ud = d;
char *p = buf + N;
if (ud >= 0) {
while (ud > 16) {
p -= 2;
if constexpr (Upper) {
std::memcpy(p, &xdigit_pairs_u[2 * (ud & 0xff)], 2);
} else {
std::memcpy(p, &xdigit_pairs_l[2 * (ud & 0xff)], 2);
}
ud /= 256;
}
while (ud > 0) {
p -= 1;
if constexpr (Upper) {
std::memcpy(p, &xdigit_pairs_u[2 * (ud & 0x0f) + 1], 1);
} else {
std::memcpy(p, &xdigit_pairs_l[2 * (ud & 0x0f) + 1], 1);
}
ud /= 16;
}
// add in any necessary padding
if (flags.padding) {
while (&buf[N] - p < width) {
*--p = '0';
}
}
// add the prefix as needed
if (flags.prefix) {
if constexpr (Upper) {
*--p = alphabet_u[16];
} else {
*--p = alphabet_l[16];
}
*--p = '0';
}
}
return std::make_tuple(p, (buf + N) - p);
} else if constexpr (Divisor == 8) {
static constexpr const char digit_pairs[129] = {"0001020304050607"
"1011121314151617"
"2021222324252627"
"3031323334353637"
"4041424344454647"
"5051525354555657"
"6061626364656667"
"7071727374757677"};
typename std::make_unsigned<T>::type ud = d;
char *p = buf + N;
if (ud >= 0) {
while (ud > 64) {
p -= 2;
std::memcpy(p, &digit_pairs[2 * (ud & 077)], 2);
ud /= 64;
}
while (ud > 0) {
p -= 1;
std::memcpy(p, &digit_pairs[2 * (ud & 007) + 1], 1);
ud /= 8;
}
// add in any necessary padding
if (flags.padding) {
while (&buf[N] - p < width) {
*--p = '0';
}
}
// add the prefix as needed
if (flags.prefix) {
*--p = '0';
}
}
return std::make_tuple(p, (buf + N) - p);
}
if constexpr (Divisor == 2) {
static constexpr const char digit_pairs[9] = {"00011011"};
typename std::make_unsigned<T>::type ud = d;
char *p = buf + N;
if (ud >= 0) {
while (ud > 4) {
p -= 2;
std::memcpy(p, &digit_pairs[2 * (ud & 0x03)], 2);
ud /= 4;
}
while (ud > 0) {
p -= 1;
std::memcpy(p, &digit_pairs[2 * (ud & 0x01) + 1], 1);
ud /= 2;
}
// add in any necessary padding
if (flags.padding) {
while (&buf[N] - p < width) {
*--p = '0';
}
}
// add the prefix as needed
if (flags.prefix) {
*--p = '0';
}
}
return std::make_tuple(p, (buf + N) - p);
}
ThrowError("Invalid Base Used In Integer To String Conversion");
}
//------------------------------------------------------------------------------
// Name: itoa
// Desc: as a minor optimization, let's determine a few things up front and pass
// them as template parameters enabling some more aggressive optimizations
// when the division can use more efficient operations
//------------------------------------------------------------------------------
template <class T, size_t N>
std::tuple<const char *, size_t> itoa(char (&buf)[N], char base, int precision, T d, int width, Flags flags) {
if (d == 0 && precision == 0) {
*buf = '\0';
return std::make_tuple(buf, 0);
}
switch (base) {
case 'i':
case 'd':
case 'u':
return format<false, 10>(buf, d, width, flags);
#ifdef CXX17_PRINTF_EXTENSIONS
case 'b':
return format<false, 2>(buf, d, width, flags);
#endif
case 'X':
return format<true, 16>(buf, d, width, flags);
case 'x':
return format<false, 16>(buf, d, width, flags);
case 'o':
return format<false, 8>(buf, d, width, flags);
default:
return format<false, 10>(buf, d, width, flags);
}
}
//------------------------------------------------------------------------------
// Name: output_string
// Desc: prints a string to the Context object, taking into account padding flags
// Note: ch is the current format specifier
//------------------------------------------------------------------------------
template <class Context>
void output_string(char ch, const char *s_ptr, int precision, long int width, Flags flags, int len, Context &ctx) noexcept {
if ((ch == 's' && precision >= 0 && precision < len)) {
len = precision;
}
// if not left justified padding goes first...
if (!flags.justify) {
// spaces go before the prefix...
while (width-- > len) {
ctx.write(' ');
}
}
// output the string
// NOTE(eteran): len is at most strlen, possibly is less
// so we can write len chars
width -= len;
ctx.write(s_ptr, len);
// if left justified padding goes last...
if (flags.justify) {
while (width-- > 0) {
ctx.write(' ');
}
}
}
// NOTE(eteran): Here is some code to fetch arguments of specific types.
#ifdef CXX17_PRINTF_EXTENSIONS
constexpr std::string formatted_object(std::string obj) {
return obj;
}
template <class T>
std::string to_string(T) {
ThrowError("No to_string found for this object type");
}
template <class T>
std::string formatted_object(T obj) {
using detail::to_string;
using std::to_string;
return to_string(obj);
}
#endif
template <class T>
constexpr const char *formatted_string([[maybe_unused]] T s) {
if constexpr (std::is_convertible<T, const char *>::value) {
return static_cast<const char *>(s);
}
ThrowError("Non-String Argument For String Format");
}
template <class R, class T>
constexpr R formatted_pointer([[maybe_unused]] T p) {
if constexpr (std::is_convertible<T, const void *>::value) {
return reinterpret_cast<R>(reinterpret_cast<uintptr_t>(p));
}
ThrowError("Non-Pointer Argument For Pointer Format");
}
template <class R, class T>
constexpr R formatted_integer([[maybe_unused]] T n) {
if constexpr (std::is_integral<T>::value) {
return static_cast<R>(n);
}
ThrowError("Non-Integer Argument For Integer Format");
}
//------------------------------------------------------------------------------
// Name: process_format
// Desc: prints the next argument to the Context taking into account the flags,
// width, precision, and modifiers collected along the way. Then will
// recursively continue processing the string
//------------------------------------------------------------------------------
template <class Context, class T, class... Ts>
int process_format(Context &ctx, const char *format, Flags flags, long int width, long int precision, Modifiers modifier, const T &arg, const Ts &... ts) {
// enough to contain a 64-bit number in bin notation + optional prefix
char num_buf[67];
size_t slen;
const char *s_ptr;
char ch = *format;
switch (ch) {
case 'e':
case 'E':
case 'f':
case 'F':
case 'a':
case 'A':
case 'g':
case 'G':
// TODO(eteran): implement float formatting... for now, just consume the argument
return Printf(ctx, format + 1, ts...);
case 'p':
precision = 1;
ch = 'x';
flags.prefix = 1;
// NOTE(eteran): GNU printf prints "(nil)" for NULL pointers, we print 0x0
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_pointer<uintptr_t>(arg), width, flags);
output_string(ch, s_ptr, precision, width, flags, slen, ctx);
return Printf(ctx, format + 1, ts...);
case 'x':
case 'X':
case 'u':
case 'o':
#ifdef CXX17_PRINTF_EXTENSIONS
case 'b': // extension, BINARY mode
#endif
if (precision < 0) {
precision = 1;
}
switch (modifier) {
case Modifiers::Char:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<unsigned char>(arg), width, flags);
break;
case Modifiers::Short:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<unsigned short int>(arg), width, flags);
break;
case Modifiers::Long:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<unsigned long int>(arg), width, flags);
break;
case Modifiers::LongLong:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<unsigned long long int>(arg), width, flags);
break;
case Modifiers::IntMaxT:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<uintmax_t>(arg), width, flags);
break;
case Modifiers::SizeT:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<size_t>(arg), width, flags);
break;
case Modifiers::PtrDiffT:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<std::make_unsigned<ptrdiff_t>::type>(arg), width, flags);
break;
default:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<unsigned int>(arg), width, flags);
break;
}
output_string(ch, s_ptr, precision, width, flags, slen, ctx);
return Printf(ctx, format + 1, ts...);
case 'i':
case 'd':
if (precision < 0) {
precision = 1;
}
switch (modifier) {
case Modifiers::Char:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<signed char>(arg), width, flags);
break;
case Modifiers::Short:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<short int>(arg), width, flags);
break;
case Modifiers::Long:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<long int>(arg), width, flags);
break;
case Modifiers::LongLong:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<long long int>(arg), width, flags);
break;
case Modifiers::IntMaxT:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<intmax_t>(arg), width, flags);
break;
case Modifiers::SizeT:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<std::make_signed<size_t>::type>(arg), width, flags);
break;
case Modifiers::PtrDiffT:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<ptrdiff_t>(arg), width, flags);
break;
default:
std::tie(s_ptr, slen) = itoa(num_buf, ch, precision, formatted_integer<int>(arg), width, flags);
break;
}
output_string(ch, s_ptr, precision, width, flags, slen, ctx);
return Printf(ctx, format + 1, ts...);
case 'c':
// char is promoted to an int when pushed on the stack
num_buf[0] = formatted_integer<char>(arg);
num_buf[1] = '\0';
s_ptr = num_buf;
output_string('c', s_ptr, precision, width, flags, 1, ctx);
return Printf(ctx, format + 1, ts...);
case 's':
s_ptr = formatted_string(arg);
if (!s_ptr) {
s_ptr = "(null)";
}
output_string('s', s_ptr, precision, width, flags, strlen(s_ptr), ctx);
return Printf(ctx, format + 1, ts...);
#ifdef CXX17_PRINTF_EXTENSIONS
case '?': {
std::string s = formatted_object(arg);
output_string('s', s.data(), precision, width, flags, s.size(), ctx);
}
return Printf(ctx, format + 1, ts...);
#endif
case 'n':
switch (modifier) {
case Modifiers::Char:
*formatted_pointer<signed char *>(arg) = ctx.written;
break;
case Modifiers::Short:
*formatted_pointer<short int *>(arg) = ctx.written;
break;
case Modifiers::Long:
*formatted_pointer<long int *>(arg) = ctx.written;
break;
case Modifiers::LongLong:
*formatted_pointer<long long int *>(arg) = ctx.written;
break;
case Modifiers::IntMaxT:
*formatted_pointer<intmax_t *>(arg) = ctx.written;
break;
case Modifiers::SizeT:
*formatted_pointer<std::make_signed<size_t>::type *>(arg) = ctx.written;
break;
case Modifiers::PtrDiffT:
*formatted_pointer<ptrdiff_t *>(arg) = ctx.written;
break;
default:
*formatted_pointer<int *>(arg) = ctx.written;
break;
}
return Printf(ctx, format + 1, ts...);
default:
ctx.write('%');
// FALL THROUGH
case '\0':
case '%':
ctx.write(ch);
break;
}
return Printf(ctx, format + 1, ts...);
}
//------------------------------------------------------------------------------
// Name: get_modifier
// Desc: gets the modifier, if any, from the format string, then calls
// process_format
//------------------------------------------------------------------------------
template <class Context, class T, class... Ts>
int get_modifier(Context &ctx, const char *format, Flags flags, long int width, long int precision, const T &arg, const Ts &... ts) {
Modifiers modifier = Modifiers::None;
switch (*format) {
case 'h':
modifier = Modifiers::Short;
++format;
if (*format == 'h') {
modifier = Modifiers::Char;
++format;
}
break;
case 'l':
modifier = Modifiers::Long;
++format;
if (*format == 'l') {
modifier = Modifiers::LongLong;
++format;
}
break;
case 'L':
modifier = Modifiers::LongDouble;
++format;
break;
case 'j':
modifier = Modifiers::IntMaxT;
++format;
break;
case 'z':
modifier = Modifiers::SizeT;
++format;
break;
case 't':
modifier = Modifiers::PtrDiffT;
++format;
break;
default:
break;
}
return process_format(ctx, format, flags, width, precision, modifier, arg, ts...);
}
//------------------------------------------------------------------------------
// Name: get_precision
// Desc: gets the precision, if any, either from the format string or as an arg
// as needed, then calls get_modifier
//------------------------------------------------------------------------------
template <class Context, class T, class... Ts>
int get_precision(Context &ctx, const char *format, Flags flags, long int width, const T &arg, const Ts &... ts) {
// default to non-existant
long int p = -1;
if (*format == '.') {
++format;
if (*format == '*') {
++format;
// pull an int off the stack for processing
p = formatted_integer<long int>(arg);
if constexpr (sizeof...(ts) > 0) {
return get_modifier(ctx, format, flags, width, p, ts...);
}
ThrowError("Internal Error");
} else {
char *endptr;
p = std::strtol(format, &endptr, 10);
format = endptr;
return get_modifier(ctx, format, flags, width, p, arg, ts...);
}
}
return get_modifier(ctx, format, flags, width, p, arg, ts...);
}
//------------------------------------------------------------------------------
// Name: get_width
// Desc: gets the width if any, either from the format string or as an arg as
// needed, then calls get_precision
//------------------------------------------------------------------------------
template <class Context, class T, class... Ts>
int get_width(Context &ctx, const char *format, Flags flags, const T &arg, const Ts &... ts) {
int width = 0;
if (*format == '*') {
++format;
// pull an int off the stack for processing
width = formatted_integer<long int>(arg);
if constexpr (sizeof...(ts) > 0) {
return get_precision(ctx, format, flags, width, ts...);
}
ThrowError("Internal Error");
} else {
char *endptr;
width = std::strtol(format, &endptr, 10);
format = endptr;
return get_precision(ctx, format, flags, width, arg, ts...);
}
}
//------------------------------------------------------------------------------
// Name: get_flags
// Desc: gets the flags, if any, from the format string, then calls get_width
//------------------------------------------------------------------------------
template <class Context, class... Ts>
int get_flags(Context &ctx, const char *format, const Ts &... ts) {
Flags f = {0, 0, 0, 0, 0, 0};
bool done = false;
// skip past the % char
++format;
do {
switch (*format) {
case '-':
// justify, overrides padding
f.justify = 1;
f.padding = 0;
++format;
break;
case '+':
// sign, overrides space
f.sign = 1;
f.space = 0;
++format;
break;
case ' ':
if (!f.sign) {
f.space = 1;
}
++format;
break;
case '#':
f.prefix = 1;
++format;
break;
case '0':
if (!f.justify) {
f.padding = 1;
}
++format;
break;
default:
done = true;
}
} while (!done);
return get_width(ctx, format, f, ts...);
}
}
//------------------------------------------------------------------------------
// Name: Printf
//------------------------------------------------------------------------------
template <class Context, class... Ts>
int Printf(Context &ctx, const char *format, const Ts &... ts) {
assert(format);
if constexpr (sizeof...(ts) > 0) {
while (LIKELY(*format != '\0')) {
if (LIKELY(*format == '%')) {
// %[flag][width][.precision][length]char
// this recurses into get_width -> get_precision -> get_length -> process_format
return detail::get_flags(ctx, format, ts...);
} else {
// do long strips of non-format chars in bulk
const char *first = format;
size_t count = 0;
do {
++format;
++count;
} while (UNLIKELY(*format != '%'));
ctx.write(first, count);
continue;
}
++format;
}
// clean up any trailing stuff
return Printf(ctx, format + 1, ts...);
} else {
for (; *format; ++format) {
if (LIKELY(*format != '%' || *++format == '%')) {
ctx.write(*format);
continue;
}
detail::ThrowError("Bad Format");
}
// this will usually null terminate the string
ctx.done();
// return the amount of bytes that should have been written if there was sufficient space
return ctx.written;
}
}
//------------------------------------------------------------------------------
// Name: snprintf
// Desc: implementation of a snprintf compatible interface
//------------------------------------------------------------------------------
template <class... Ts>
int sprintf(std::ostream &os, const char *format, const Ts &... ts) {
ostream_writer ctx(os);
return Printf(ctx, format, ts...);
}
//------------------------------------------------------------------------------
// Name: snprintf
// Desc: implementation of a snprintf compatible interface, fixed bufer size safe!
//------------------------------------------------------------------------------
template <size_t N, class... Ts>
int sprintf(char (&buffer)[N], const char *format, const Ts &... ts) {
buffer_writer ctx(buffer);
return Printf(ctx, format, ts...);
}
//------------------------------------------------------------------------------
// Name: sprintf
// Desc: implementation of a s[n]printf compatible interface
//------------------------------------------------------------------------------
template <class... Ts>
int sprintf(char *str, size_t size, const char *format, const Ts &... ts) {
buffer_writer ctx(str, size);
return Printf(ctx, format, ts...);
}
//------------------------------------------------------------------------------
// Name: printf
// Desc: implementation of a printf compatible interface
//------------------------------------------------------------------------------
template <class... Ts>
int printf(const char *format, const Ts &... ts) {
stdout_writer ctx;
return Printf(ctx, format, ts...);
}
}
#undef LIKELY
#undef UNLIKELY
#endif