Cleanup: Move *_loc formatting functions into new format.cpp file

qthelper.cpp is already quite voluminous. Move the recently
introduced localized versions of (v)snprintf() and put_format()
into their own translation unit.

Moreover, adopt C-style semantics for asprintf_loc(). This function
will be used to remove fixed-size buffers in core/plannernotes.c.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>

1 files changed, 414 insertions, 0 deletions

diff --git a/core/format.cpp b/core/format.cpp
new file mode 100644
index 000000000..5793bff02
--- /dev/null
+++ b/core/format.cpp
@@ -0,0 +1,414 @@
+// SPDX-License-Identifier: GPL-2.0
+#include "format.h"
+#include "membuffer.h"
+
+QString qasprintf_loc(const char *cformat, ...)
+{
+	va_list ap;
+	va_start(ap, cformat);
+	QString res = vqasprintf_loc(cformat, ap);
+	va_end(ap);
+	return res;
+}
+
+struct vasprintf_flags {
+	bool alternate_form : 1;	// TODO: unsupported
+	bool zero : 1;
+	bool left : 1;
+	bool space : 1;
+	bool sign : 1;
+	bool thousands : 1;		// ignored
+};
+
+enum length_modifier_t {
+	LM_NONE,
+	LM_CHAR,
+	LM_SHORT,
+	LM_LONG,
+	LM_LONGLONG,
+	LM_LONGDOUBLE,
+	LM_INTMAX,
+	LM_SIZET,
+	LM_PTRDIFF
+};
+
+// Helper function to insert '+' or ' ' after last space
+static QString insert_sign(QString s, char sign)
+{
+	// For space we can take a shortcut: insert in front
+	if (sign == ' ')
+		return sign + s;
+	int size = s.size();
+	int pos;
+	for (pos = 0; pos < size && s[pos].isSpace(); ++pos)
+		;	// Pass
+	return s.left(pos) + '+' + s.mid(pos);
+}
+
+static QString fmt_string(const QString &s, vasprintf_flags flags, int field_width, int precision)
+{
+	int size = s.size();
+	if (precision >= 0 && size > precision)
+		return s.left(precision);
+	return flags.left ? s.leftJustified(field_width) :
+			    s.rightJustified(field_width);
+}
+
+// Formatting of integers and doubles using Qt's localized functions.
+// The code is somewhat complex because Qt doesn't support all stdio
+// format options, notably '+' and ' '.
+// TODO: Since this is a templated function, remove common code
+template <typename T>
+static QString fmt_int(T i, vasprintf_flags flags, int field_width, int precision, int base)
+{
+	// If precision is given, things are a bit different: we have to pad with zero *and* space.
+	// Therefore, treat this case separately.
+	if (precision > 1) {
+		// For negative numbers, increase precision by one, so that we get
+		// the correct number of printed digits
+		if (i < 0)
+			++precision;
+		QChar fillChar = '0';
+		QString res = QStringLiteral("%L1").arg(i, precision, base, fillChar);
+		if (i >= 0 && flags.space)
+			res = ' ' + res;
+		else if (i >= 0 && flags.sign)
+			res = '+' + res;
+		return fmt_string(res, flags, field_width, -1);
+	}
+
+	// If we have to prepend a '+' or a space character, remove that from the field width
+	char sign = 0;
+	if (i >= 0 && (flags.space || flags.sign) && field_width > 0) {
+		sign = flags.sign ? '+' : ' ';
+		--field_width;
+	}
+	if (flags.left)
+		field_width = -field_width;
+	QChar fillChar = flags.zero && !flags.left ? '0' : ' ';
+	QString res = QStringLiteral("%L1").arg(i, field_width, base, fillChar);
+	return sign ? insert_sign(res, sign) : res;
+}
+
+static QString fmt_float(double d, char type, vasprintf_flags flags, int field_width, int precision)
+{
+	// If we have to prepend a '+' or a space character, remove that from the field width
+	char sign = 0;
+	if (d >= 0.0 && (flags.space || flags.sign) && field_width > 0) {
+		sign = flags.sign ? '+' : ' ';
+		--field_width;
+	}
+	if (flags.left)
+		field_width = -field_width;
+	QChar fillChar = flags.zero && !flags.left ? '0' : ' ';
+	QString res = QStringLiteral("%L1").arg(d, field_width, type, precision, fillChar);
+	return sign ? insert_sign(res, sign) : res;
+}
+
+// Helper to extract integers from C-style format strings.
+// The default returned value, if no digits are found is 0.
+static int parse_fmt_int(const char **act)
+{
+	if (!isdigit(**act))
+		return 0;
+	int res = 0;
+	while (isdigit(**act)) {
+		res = res * 10 + **act - '0';
+		++(*act);
+	}
+	return res;
+}
+
+QString vqasprintf_loc(const char *fmt, va_list ap)
+{
+	const char *act = fmt;
+	QString ret;
+	for (;;) {
+		// Get all bytes up to next '%' character and add them as UTF-8
+		const char *begin = act;
+		while (*act && *act != '%')
+			++act;
+		int len = act - begin;
+		if (len > 0)
+			ret += QString::fromUtf8(begin, len);
+
+		// We found either a '%' or the end of the format string
+		if (!*act)
+			break;
+		++act;	// Jump over '%'
+
+		if (*act == '%') {
+			++act;
+			ret += '%';
+			continue;
+		}
+		// Flags
+		vasprintf_flags flags = { 0 };
+		for (;; ++act) {
+			switch(*act) {
+			case '#':
+				flags.alternate_form = true;
+				continue;
+			case '0':
+				flags.zero = true;
+				continue;
+			case '-':
+				flags.left = true;
+				continue;
+			case ' ':
+				flags.space = true;
+				continue;
+			case '+':
+				flags.sign = true;
+				continue;
+			case '\'':
+				flags.thousands = true;
+				continue;
+			}
+			break;
+		}
+
+		// Field width
+		int field_width;
+		if (*act == '*') {
+			field_width = va_arg(ap, int);
+			++act;
+		} else {
+			field_width = parse_fmt_int(&act);
+		}
+
+		// Precision
+		int precision = -1;
+		if (*act == '.') {
+			++act;
+			if (*act == '*') {
+				precision = va_arg(ap, int);
+				++act;
+			} else {
+				precision = parse_fmt_int(&act);
+			}
+		}
+
+		// Length modifier
+		enum length_modifier_t length_modifier = LM_NONE;
+		switch(*act) {
+		case 'h':
+			++act;
+			length_modifier = LM_CHAR;
+			if (*act == 'h') {
+				length_modifier = LM_SHORT;
+				++act;
+			}
+			break;
+		case 'l':
+			++act;
+			length_modifier = LM_LONG;
+			if (*act == 'l') {
+				length_modifier = LM_LONGLONG;
+				++act;
+			}
+			break;
+		case 'q':
+			++act;
+			length_modifier = LM_LONGLONG;
+			break;
+		case 'L':
+			++act;
+			length_modifier = LM_LONGDOUBLE;
+			break;
+		case 'j':
+			++act;
+			length_modifier = LM_INTMAX;
+			break;
+		case 'z':
+		case 'Z':
+			++act;
+			length_modifier = LM_SIZET;
+			break;
+		case 't':
+			++act;
+			length_modifier = LM_PTRDIFF;
+			break;
+		}
+
+		char type = *act++;
+		// Bail out if we reached end of the format string
+		if (!type)
+			break;
+
+		int base = 10;
+		if (type == 'o')
+			base = 8;
+		else if (type == 'x' || type == 'X')
+			base = 16;
+
+		switch(type) {
+		case 'd': case 'i': {
+			switch(length_modifier) {
+			case LM_LONG:
+				ret += fmt_int(va_arg(ap, long), flags, field_width, precision, base);
+				break;
+			case LM_LONGLONG:
+				ret += fmt_int(va_arg(ap, long long), flags, field_width, precision, base);
+				break;
+			case LM_INTMAX:
+				ret += fmt_int(va_arg(ap, intmax_t), flags, field_width, precision, base);
+				break;
+			case LM_SIZET:
+				ret += fmt_int(va_arg(ap, ssize_t), flags, field_width, precision, base);
+				break;
+			case LM_PTRDIFF:
+				ret += fmt_int(va_arg(ap, ptrdiff_t), flags, field_width, precision, base);
+				break;
+			case LM_CHAR:
+				// char is promoted to int when passed through '...'
+				ret += fmt_int(static_cast<char>(va_arg(ap, int)), flags, field_width, precision, base);
+				break;
+			case LM_SHORT:
+				// short is promoted to int when passed through '...'
+				ret += fmt_int(static_cast<short>(va_arg(ap, int)), flags, field_width, precision, base);
+				break;
+			default:
+				ret += fmt_int(va_arg(ap, int), flags, field_width, precision, base);
+				break;
+			}
+			break;
+		}
+		case 'o': case 'u': case 'x': case 'X': {
+			QString s;
+			switch(length_modifier) {
+			case LM_LONG:
+				s = fmt_int(va_arg(ap, unsigned long), flags, field_width, precision, base);
+				break;
+			case LM_LONGLONG:
+				s = fmt_int(va_arg(ap, unsigned long long), flags, field_width, precision, base);
+				break;
+			case LM_INTMAX:
+				s = fmt_int(va_arg(ap, uintmax_t), flags, field_width, precision, base);
+				break;
+			case LM_SIZET:
+				s = fmt_int(va_arg(ap, size_t), flags, field_width, precision, base);
+				break;
+			case LM_PTRDIFF:
+				s = fmt_int(va_arg(ap, ptrdiff_t), flags, field_width, precision, base);
+				break;
+			case LM_CHAR:
+				// char is promoted to int when passed through '...'
+				s = fmt_int(static_cast<unsigned char>(va_arg(ap, int)), flags, field_width, precision, base);
+				break;
+			case LM_SHORT:
+				// short is promoted to int when passed through '...'
+				s = fmt_int(static_cast<unsigned short>(va_arg(ap, int)), flags, field_width, precision, base);
+				break;
+			default:
+				s = fmt_int(va_arg(ap, unsigned int), flags, field_width, precision, base);
+				break;
+			}
+			if (type == 'X')
+				s = s.toUpper();
+			ret += s;
+			break;
+		}
+		case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': {
+			// It seems that Qt is not able to format long doubles,
+			// therefore we have to cast down to double.
+			double f = length_modifier == LM_LONGDOUBLE ?
+				static_cast<double>(va_arg(ap, long double)) :
+				va_arg(ap, double);
+			ret += fmt_float(f, type, flags, field_width, precision);
+			break;
+		}
+		case 'c':
+			if (length_modifier == LM_LONG) {
+				// Cool, on some platforms wint_t is short, on some int.
+#if WINT_MAX < UINT_MAX
+				wint_t wc = static_cast<wint_t>(va_arg(ap, int));
+#else
+				wint_t wc = va_arg(ap, wint_t);
+#endif
+				ret += QChar(wc);
+			} else {
+				ret += static_cast<char>(va_arg(ap, int));
+			}
+			break;
+		case 's': {
+			QString s = length_modifier == LM_LONG ?
+				QString::fromWCharArray(va_arg(ap, wchar_t *)) :
+				QString::fromUtf8(va_arg(ap, char *));
+			ret += fmt_string(s, flags, field_width, precision);
+			break;
+		}
+		case 'p':
+			ret += QString("0x%1").arg(reinterpret_cast<long long>(va_arg(ap, void *)), field_width, 16);
+			break;
+		}
+	}
+	return ret;
+}
+
+// Put a formated string respecting the default locale into a C-style array in UTF-8 encoding.
+// The only complication arises from the fact that we don't want to cut through multi-byte UTF-8 code points.
+extern "C" int snprintf_loc(char *dst, size_t size, const char *cformat, ...)
+{
+	va_list ap;
+	va_start(ap, cformat);
+	int res = vsnprintf_loc(dst, size, cformat, ap);
+	va_end(ap);
+	return res;
+}
+
+extern "C" int vsnprintf_loc(char *dst, size_t size, const char *cformat, va_list ap)
+{
+	QByteArray utf8 = vqasprintf_loc(cformat, ap).toUtf8();
+	const char *data = utf8.constData();
+	size_t utf8_size = utf8.size();
+	if (size == 0)
+		return utf8_size;
+	if (size < utf8_size + 1) {
+		memcpy(dst, data, size - 1);
+		if ((data[size - 1] & 0xC0) == 0x80) {
+			// We truncated a multi-byte UTF-8 encoding.
+			--size;
+			// Jump to last copied byte.
+			if (size > 0)
+				--size;
+			while(size > 0 && (dst[size] & 0xC0) == 0x80)
+				--size;
+			dst[size] = 0;
+		} else {
+			dst[size - 1] = 0;
+		}
+	} else {
+		memcpy(dst, data, utf8_size + 1); // QByteArray guarantees a trailing 0
+	}
+	return utf8_size;
+}
+
+int asprintf_loc(char **dst, const char *cformat, ...)
+{
+	va_list ap;
+	va_start(ap, cformat);
+	int res = vasprintf_loc(dst, cformat, ap);
+	va_end(ap);
+	return res;
+}
+
+int vasprintf_loc(char **dst, const char *cformat, va_list ap)
+{
+	QByteArray utf8 = vqasprintf_loc(cformat, ap).toUtf8();
+	*dst = strdup(utf8.constData());
+	return utf8.size();
+}
+
+// This function is defined here instead of membuffer.c, because it needs to access QString.
+extern "C" void put_vformat_loc(struct membuffer *b, const char *fmt, va_list args)
+{
+	QByteArray utf8 = vqasprintf_loc(fmt, args).toUtf8();
+	const char *data = utf8.constData();
+	size_t utf8_size = utf8.size();
+
+	make_room(b, utf8_size);
+	memcpy(b->buffer + b->len, data, utf8_size);
+	b->len += utf8_size;
+}
+