moved string formatting into CStringUtil from CLog and added

methods for format positional string arguments.

base/CString.cpp

@@ -1,7 +1,159 @@
 #include "CString.h"
+#include "stdvector.h"
 #include <cctype>
+#include <cstdio>
+#include <cstdlib>
 #include <algorithm>
 
+#if WINDOWS_LIKE
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#define vsnprintf _vsnprintf
+#endif
+
+//
+// CStringUtil
+//
+
+CString
+CStringUtil::format(const char* fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	CString result = vformat(fmt, args);
+	va_end(args);
+	return result;
+}
+
+CString
+CStringUtil::vformat(const char* fmt, va_list args)
+{
+	// find highest indexed substitution and the locations of substitutions
+	std::vector<size_t> pos;
+	std::vector<size_t> width;
+	std::vector<int> index;
+	int maxIndex = 0;
+	for (const char* scan = fmt; *scan != '\0'; ++scan) {
+		if (*scan == '%') {
+			++scan;
+			if (*scan == '\0') {
+				break;
+			}
+			else if (*scan == '%') {
+				// literal
+				index.push_back(0);
+				pos.push_back(static_cast<int>(scan - 1 - fmt));
+				width.push_back(2);
+			}
+			else if (*scan == '{') {
+				// get argument index
+				char* end;
+				int i = static_cast<int>(strtol(scan + 1, &end, 10));
+				if (*end != '}') {
+					// invalid index -- ignore
+					scan = end - 1;
+				}
+				else {
+					index.push_back(i);
+					pos.push_back(static_cast<int>(scan - 1 - fmt));
+					width.push_back(static_cast<int>(end - scan + 2));
+					if (i > maxIndex) {
+						maxIndex = i;
+					}
+					scan = end;
+				}
+			}
+			else {
+				// improper escape -- ignore
+			}
+		}
+	}
+
+	// get args
+	std::vector<const char*> value;
+	std::vector<size_t> length;
+	value.push_back("%");
+	length.push_back(1);
+	for (int i = 0; i < maxIndex; ++i) {
+		const char* arg = va_arg(args, const char*);
+		value.push_back(arg);
+		length.push_back(strlen(arg));
+	}
+
+	// compute final length
+	size_t resultLength = strlen(fmt);
+	const int n = static_cast<int>(pos.size());
+	for (int i = 0; i < n; ++i) {
+		resultLength -= width[i];
+		resultLength += length[index[i]];
+	}
+
+	// substitute
+	CString result;
+	result.reserve(resultLength);
+	size_t src = 0;
+	for (int i = 0; i < n; ++i) {
+		result.append(fmt + src, pos[i] - src);
+		result.append(value[index[i]]);
+		src = pos[i] + width[i];
+	}
+	result.append(fmt + src);
+
+	return result;
+}
+
+CString
+CStringUtil::print(const char* fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	CString result = vprint(fmt, args);
+	va_end(args);
+	return result;
+}
+
+CString
+CStringUtil::vprint(const char* fmt, va_list args)
+{
+	char tmp[1024];
+	char* buffer = vsprint(tmp, sizeof(tmp) / sizeof(tmp[0]), 0, 0, fmt, args);
+	if (buffer == tmp) {
+		return buffer;
+	}
+	else {
+		CString result(buffer);
+		delete[] buffer;
+		return result;
+	}
+}
+
+char*
+CStringUtil::vsprint(char* buffer, int len,
+				int prefix, int suffix, const char* fmt, va_list args)
+{
+	assert(len > 0);
+
+	// try writing to input buffer
+	int n;
+	if (buffer != NULL && len >= prefix + suffix) {
+		n = vsnprintf(buffer + prefix, len - (prefix + suffix), fmt, args);
+		if (n >= 0 && n <= len - (prefix + suffix))
+			return buffer;
+	}
+
+	// start allocating buffers until we write the whole string
+	buffer = NULL;
+	do {
+		delete[] buffer;
+		len *= 2;
+		buffer = new char[len + (prefix + suffix)];
+		n = vsnprintf(buffer + prefix, len - (prefix + suffix), fmt, args);
+	} while (n < 0 || n > len - (prefix + suffix));
+
+	return buffer;
+}
+
+
 //
 // CStringUtil::CaselessCmp
 //
@@ -11,7 +163,7 @@ CStringUtil::CaselessCmp::cmpEqual(
 				const CString::value_type& a,
 				const CString::value_type& b)
 {
-	// FIXME -- use std::tolower but not in all versions of libstdc++
+	// FIXME -- use std::tolower but not in all versions of libstdc++ have it
 	return tolower(a) == tolower(b);
 }
 
@@ -20,7 +172,7 @@ CStringUtil::CaselessCmp::cmpLess(
 				const CString::value_type& a,
 				const CString::value_type& b)
 {
-	// FIXME -- use std::tolower but not in all versions of libstdc++
+	// FIXME -- use std::tolower but not in all versions of libstdc++ have it
 	return tolower(a) < tolower(b);
 }