summaryrefslogtreecommitdiffstats
path: root/src/VBox/Runtime/common/string/strformatrt.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/VBox/Runtime/common/string/strformatrt.cpp')
-rw-r--r--src/VBox/Runtime/common/string/strformatrt.cpp1647
1 files changed, 1647 insertions, 0 deletions
diff --git a/src/VBox/Runtime/common/string/strformatrt.cpp b/src/VBox/Runtime/common/string/strformatrt.cpp
new file mode 100644
index 00000000..a23da826
--- /dev/null
+++ b/src/VBox/Runtime/common/string/strformatrt.cpp
@@ -0,0 +1,1647 @@
+/* $Id: strformatrt.cpp $ */
+/** @file
+ * IPRT - IPRT String Formatter Extensions.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP RTLOGGROUP_STRING
+#include <iprt/string.h>
+#ifndef RT_NO_EXPORT_SYMBOL
+# define RT_NO_EXPORT_SYMBOL /* don't slurp <linux/module.h> which then again
+ slurps arch-specific headers defining symbols */
+#endif
+#include "internal/iprt.h"
+
+#include <iprt/log.h>
+#include <iprt/assert.h>
+#include <iprt/string.h>
+#include <iprt/stdarg.h>
+#ifdef IN_RING3
+# include <iprt/errcore.h>
+# include <iprt/thread.h>
+# include <iprt/utf16.h>
+#endif
+#include <iprt/ctype.h>
+#include <iprt/time.h>
+#include <iprt/net.h>
+#include <iprt/path.h>
+#include <iprt/asm.h>
+#define STRFORMAT_WITH_X86
+#ifdef STRFORMAT_WITH_X86
+# include <iprt/x86.h>
+#endif
+#include "internal/string.h"
+
+
+/*********************************************************************************************************************************
+* Global Variables *
+*********************************************************************************************************************************/
+static char g_szHexDigits[17] = "0123456789abcdef";
+#ifdef IN_RING3
+static char g_szHexDigitsUpper[17] = "0123456789ABCDEF";
+#endif
+
+
+/**
+ * Helper that formats a 16-bit hex word in a IPv6 address.
+ *
+ * @returns Length in chars.
+ * @param pszDst The output buffer. Written from the start.
+ * @param uWord The word to format as hex.
+ */
+static size_t rtstrFormatIPv6HexWord(char *pszDst, uint16_t uWord)
+{
+ size_t off;
+ uint16_t cDigits;
+
+ if (uWord & UINT16_C(0xff00))
+ cDigits = uWord & UINT16_C(0xf000) ? 4 : 3;
+ else
+ cDigits = uWord & UINT16_C(0x00f0) ? 2 : 1;
+
+ off = 0;
+ switch (cDigits)
+ {
+ case 4: pszDst[off++] = g_szHexDigits[(uWord >> 12) & 0xf]; RT_FALL_THRU();
+ case 3: pszDst[off++] = g_szHexDigits[(uWord >> 8) & 0xf]; RT_FALL_THRU();
+ case 2: pszDst[off++] = g_szHexDigits[(uWord >> 4) & 0xf]; RT_FALL_THRU();
+ case 1: pszDst[off++] = g_szHexDigits[(uWord >> 0) & 0xf];
+ break;
+ }
+ pszDst[off] = '\0';
+ return off;
+}
+
+
+/**
+ * Helper function to format IPv6 address according to RFC 5952.
+ *
+ * @returns The number of bytes formatted.
+ * @param pfnOutput Pointer to output function.
+ * @param pvArgOutput Argument for the output function.
+ * @param pIpv6Addr IPv6 address
+ */
+static size_t rtstrFormatIPv6(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, PCRTNETADDRIPV6 pIpv6Addr)
+{
+ size_t cch; /* result */
+ bool fEmbeddedIpv4;
+ size_t cwHexPart;
+ size_t cwLongestZeroRun;
+ size_t iLongestZeroStart;
+ size_t idx;
+ char szHexWord[8];
+
+ Assert(pIpv6Addr != NULL);
+
+ /*
+ * Check for embedded IPv4 address.
+ *
+ * IPv4-compatible - ::11.22.33.44 (obsolete)
+ * IPv4-mapped - ::ffff:11.22.33.44
+ * IPv4-translated - ::ffff:0:11.22.33.44 (RFC 2765)
+ */
+ fEmbeddedIpv4 = false;
+ cwHexPart = RT_ELEMENTS(pIpv6Addr->au16);
+ if ( pIpv6Addr->au64[0] == 0
+ && ( ( pIpv6Addr->au32[2] == 0
+ && pIpv6Addr->au32[3] != 0
+ && pIpv6Addr->au32[3] != RT_H2BE_U32_C(1) )
+ || pIpv6Addr->au32[2] == RT_H2BE_U32_C(0x0000ffff)
+ || pIpv6Addr->au32[2] == RT_H2BE_U32_C(0xffff0000) ) )
+ {
+ fEmbeddedIpv4 = true;
+ cwHexPart -= 2;
+ }
+
+ /*
+ * Find the longest sequences of two or more zero words.
+ */
+ cwLongestZeroRun = 0;
+ iLongestZeroStart = 0;
+ for (idx = 0; idx < cwHexPart; idx++)
+ if (pIpv6Addr->au16[idx] == 0)
+ {
+ size_t iZeroStart = idx;
+ size_t cwZeroRun;
+ do
+ idx++;
+ while (idx < cwHexPart && pIpv6Addr->au16[idx] == 0);
+ cwZeroRun = idx - iZeroStart;
+ if (cwZeroRun > 1 && cwZeroRun > cwLongestZeroRun)
+ {
+ cwLongestZeroRun = cwZeroRun;
+ iLongestZeroStart = iZeroStart;
+ if (cwZeroRun >= cwHexPart - idx)
+ break;
+ }
+ }
+
+ /*
+ * Do the formatting.
+ */
+ cch = 0;
+ if (cwLongestZeroRun == 0)
+ {
+ for (idx = 0; idx < cwHexPart; ++idx)
+ {
+ if (idx > 0)
+ cch += pfnOutput(pvArgOutput, ":", 1);
+ cch += pfnOutput(pvArgOutput, szHexWord, rtstrFormatIPv6HexWord(szHexWord, RT_BE2H_U16(pIpv6Addr->au16[idx])));
+ }
+
+ if (fEmbeddedIpv4)
+ cch += pfnOutput(pvArgOutput, ":", 1);
+ }
+ else
+ {
+ const size_t iLongestZeroEnd = iLongestZeroStart + cwLongestZeroRun;
+
+ if (iLongestZeroStart == 0)
+ cch += pfnOutput(pvArgOutput, ":", 1);
+ else
+ for (idx = 0; idx < iLongestZeroStart; ++idx)
+ {
+ cch += pfnOutput(pvArgOutput, szHexWord, rtstrFormatIPv6HexWord(szHexWord, RT_BE2H_U16(pIpv6Addr->au16[idx])));
+ cch += pfnOutput(pvArgOutput, ":", 1);
+ }
+
+ if (iLongestZeroEnd == cwHexPart)
+ cch += pfnOutput(pvArgOutput, ":", 1);
+ else
+ {
+ for (idx = iLongestZeroEnd; idx < cwHexPart; ++idx)
+ {
+ cch += pfnOutput(pvArgOutput, ":", 1);
+ cch += pfnOutput(pvArgOutput, szHexWord, rtstrFormatIPv6HexWord(szHexWord, RT_BE2H_U16(pIpv6Addr->au16[idx])));
+ }
+
+ if (fEmbeddedIpv4)
+ cch += pfnOutput(pvArgOutput, ":", 1);
+ }
+ }
+
+ if (fEmbeddedIpv4)
+ cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%u.%u.%u.%u",
+ pIpv6Addr->au8[12],
+ pIpv6Addr->au8[13],
+ pIpv6Addr->au8[14],
+ pIpv6Addr->au8[15]);
+
+ return cch;
+}
+
+
+/**
+ * Callback to format iprt formatting extentions.
+ * See @ref pg_rt_str_format for a reference on the format types.
+ *
+ * @returns The number of bytes formatted.
+ * @param pfnOutput Pointer to output function.
+ * @param pvArgOutput Argument for the output function.
+ * @param ppszFormat Pointer to the format string pointer. Advance this till the char
+ * after the format specifier.
+ * @param pArgs Pointer to the argument list. Use this to fetch the arguments.
+ * @param cchWidth Format Width. -1 if not specified.
+ * @param cchPrecision Format Precision. -1 if not specified.
+ * @param fFlags Flags (RTSTR_NTFS_*).
+ * @param chArgSize The argument size specifier, 'l' or 'L'.
+ */
+DECLHIDDEN(size_t) rtstrFormatRt(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, const char **ppszFormat, va_list *pArgs,
+ int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize)
+{
+ const char *pszFormatOrg = *ppszFormat;
+ char ch = *(*ppszFormat)++;
+ size_t cch;
+ char szBuf[80];
+
+ if (ch == 'R')
+ {
+ ch = *(*ppszFormat)++;
+ switch (ch)
+ {
+ /*
+ * Groups 1 and 2.
+ */
+ case 'T':
+ case 'G':
+ case 'H':
+ case 'R':
+ case 'C':
+ case 'I':
+ case 'X':
+ case 'U':
+ case 'K':
+ {
+ /*
+ * Interpret the type.
+ */
+ typedef enum
+ {
+ RTSF_INT,
+ RTSF_INTW,
+ RTSF_BOOL,
+ RTSF_FP16,
+ RTSF_FP32,
+ RTSF_FP64,
+ RTSF_IPV4,
+ RTSF_IPV6,
+ RTSF_MAC,
+ RTSF_NETADDR,
+ RTSF_UUID
+ } RTSF;
+ static const struct
+ {
+ uint8_t cch; /**< the length of the string. */
+ char sz[10]; /**< the part following 'R'. */
+ uint8_t cb; /**< the size of the type. */
+ uint8_t u8Base; /**< the size of the type. */
+ RTSF enmFormat; /**< The way to format it. */
+ uint16_t fFlags; /**< additional RTSTR_F_* flags. */
+ }
+ /** Sorted array of types, looked up using binary search! */
+ s_aTypes[] =
+ {
+#define STRMEM(str) sizeof(str) - 1, str
+ { STRMEM("Ci"), sizeof(RTINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Cp"), sizeof(RTCCPHYS), 16, RTSF_INTW, 0 },
+ { STRMEM("Cr"), sizeof(RTCCUINTREG), 16, RTSF_INTW, 0 },
+ { STRMEM("Cu"), sizeof(RTUINT), 10, RTSF_INT, 0 },
+ { STRMEM("Cv"), sizeof(void *), 16, RTSF_INTW, 0 },
+ { STRMEM("Cx"), sizeof(RTUINT), 16, RTSF_INT, 0 },
+ { STRMEM("Gi"), sizeof(RTGCINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Gp"), sizeof(RTGCPHYS), 16, RTSF_INTW, 0 },
+ { STRMEM("Gr"), sizeof(RTGCUINTREG), 16, RTSF_INTW, 0 },
+ { STRMEM("Gu"), sizeof(RTGCUINT), 10, RTSF_INT, 0 },
+ { STRMEM("Gv"), sizeof(RTGCPTR), 16, RTSF_INTW, 0 },
+ { STRMEM("Gx"), sizeof(RTGCUINT), 16, RTSF_INT, 0 },
+ { STRMEM("Hi"), sizeof(RTHCINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Hp"), sizeof(RTHCPHYS), 16, RTSF_INTW, 0 },
+ { STRMEM("Hr"), sizeof(RTHCUINTREG), 16, RTSF_INTW, 0 },
+ { STRMEM("Hu"), sizeof(RTHCUINT), 10, RTSF_INT, 0 },
+ { STRMEM("Hv"), sizeof(RTHCPTR), 16, RTSF_INTW, 0 },
+ { STRMEM("Hx"), sizeof(RTHCUINT), 16, RTSF_INT, 0 },
+ { STRMEM("I16"), sizeof(int16_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("I32"), sizeof(int32_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("I64"), sizeof(int64_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("I8"), sizeof(int8_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Kv"), sizeof(RTHCPTR), 16, RTSF_INT, RTSTR_F_OBFUSCATE_PTR },
+ { STRMEM("Rv"), sizeof(RTRCPTR), 16, RTSF_INTW, 0 },
+ { STRMEM("Tbool"), sizeof(bool), 10, RTSF_BOOL, 0 },
+ { STRMEM("Tfile"), sizeof(RTFILE), 10, RTSF_INT, 0 },
+ { STRMEM("Tfmode"), sizeof(RTFMODE), 16, RTSF_INTW, 0 },
+ { STRMEM("Tfoff"), sizeof(RTFOFF), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Tfp16"), sizeof(RTFAR16), 16, RTSF_FP16, RTSTR_F_ZEROPAD },
+ { STRMEM("Tfp32"), sizeof(RTFAR32), 16, RTSF_FP32, RTSTR_F_ZEROPAD },
+ { STRMEM("Tfp64"), sizeof(RTFAR64), 16, RTSF_FP64, RTSTR_F_ZEROPAD },
+ { STRMEM("Tgid"), sizeof(RTGID), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Tino"), sizeof(RTINODE), 16, RTSF_INTW, 0 },
+ { STRMEM("Tint"), sizeof(RTINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Tiop"), sizeof(RTIOPORT), 16, RTSF_INTW, 0 },
+ { STRMEM("Tldrm"), sizeof(RTLDRMOD), 16, RTSF_INTW, 0 },
+ { STRMEM("Tmac"), sizeof(PCRTMAC), 16, RTSF_MAC, 0 },
+ { STRMEM("Tnaddr"), sizeof(PCRTNETADDR), 10, RTSF_NETADDR,0 },
+ { STRMEM("Tnaipv4"), sizeof(RTNETADDRIPV4), 10, RTSF_IPV4, 0 },
+ { STRMEM("Tnaipv6"), sizeof(PCRTNETADDRIPV6),16, RTSF_IPV6, 0 },
+ { STRMEM("Tnthrd"), sizeof(RTNATIVETHREAD), 16, RTSF_INTW, 0 },
+ { STRMEM("Tproc"), sizeof(RTPROCESS), 16, RTSF_INTW, 0 },
+ { STRMEM("Tptr"), sizeof(RTUINTPTR), 16, RTSF_INTW, 0 },
+ { STRMEM("Treg"), sizeof(RTCCUINTREG), 16, RTSF_INTW, 0 },
+ { STRMEM("Tsel"), sizeof(RTSEL), 16, RTSF_INTW, 0 },
+ { STRMEM("Tsem"), sizeof(RTSEMEVENT), 16, RTSF_INTW, 0 },
+ { STRMEM("Tsock"), sizeof(RTSOCKET), 10, RTSF_INT, 0 },
+ { STRMEM("Tthrd"), sizeof(RTTHREAD), 16, RTSF_INTW, 0 },
+ { STRMEM("Tuid"), sizeof(RTUID), 10, RTSF_INT, RTSTR_F_VALSIGNED },
+ { STRMEM("Tuint"), sizeof(RTUINT), 10, RTSF_INT, 0 },
+ { STRMEM("Tunicp"), sizeof(RTUNICP), 16, RTSF_INTW, RTSTR_F_ZEROPAD },
+ { STRMEM("Tutf16"), sizeof(RTUTF16), 16, RTSF_INTW, RTSTR_F_ZEROPAD },
+ { STRMEM("Tuuid"), sizeof(PCRTUUID), 16, RTSF_UUID, 0 },
+ { STRMEM("Txint"), sizeof(RTUINT), 16, RTSF_INT, 0 },
+ { STRMEM("U16"), sizeof(uint16_t), 10, RTSF_INT, 0 },
+ { STRMEM("U32"), sizeof(uint32_t), 10, RTSF_INT, 0 },
+ { STRMEM("U64"), sizeof(uint64_t), 10, RTSF_INT, 0 },
+ { STRMEM("U8"), sizeof(uint8_t), 10, RTSF_INT, 0 },
+ { STRMEM("X16"), sizeof(uint16_t), 16, RTSF_INT, 0 },
+ { STRMEM("X32"), sizeof(uint32_t), 16, RTSF_INT, 0 },
+ { STRMEM("X64"), sizeof(uint64_t), 16, RTSF_INT, 0 },
+ { STRMEM("X8"), sizeof(uint8_t), 16, RTSF_INT, 0 },
+#undef STRMEM
+ };
+ static const char s_szNull[] = "<NULL>";
+
+ const char *pszType = *ppszFormat - 1;
+ int iStart = 0;
+ int iEnd = RT_ELEMENTS(s_aTypes) - 1;
+ int i = RT_ELEMENTS(s_aTypes) / 2;
+
+ union
+ {
+ uint8_t u8;
+ uint16_t u16;
+ uint32_t u32;
+ uint64_t u64;
+ int8_t i8;
+ int16_t i16;
+ int32_t i32;
+ int64_t i64;
+ RTR0INTPTR uR0Ptr;
+ RTFAR16 fp16;
+ RTFAR32 fp32;
+ RTFAR64 fp64;
+ bool fBool;
+ PCRTMAC pMac;
+ RTNETADDRIPV4 Ipv4Addr;
+ PCRTNETADDRIPV6 pIpv6Addr;
+ PCRTNETADDR pNetAddr;
+ PCRTUUID pUuid;
+ } u;
+
+ AssertMsg(!chArgSize, ("Not argument size '%c' for RT types! '%.10s'\n", chArgSize, pszFormatOrg));
+ RT_NOREF_PV(chArgSize);
+
+ /*
+ * Lookup the type - binary search.
+ */
+ for (;;)
+ {
+ int iDiff = strncmp(pszType, s_aTypes[i].sz, s_aTypes[i].cch);
+ if (!iDiff)
+ break;
+ if (iEnd == iStart)
+ {
+ AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+ if (iDiff < 0)
+ iEnd = i - 1;
+ else
+ iStart = i + 1;
+ if (iEnd < iStart)
+ {
+ AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+ i = iStart + (iEnd - iStart) / 2;
+ }
+
+ /*
+ * Advance the format string and merge flags.
+ */
+ *ppszFormat += s_aTypes[i].cch - 1;
+ fFlags |= s_aTypes[i].fFlags;
+
+ /*
+ * Fetch the argument.
+ * It's important that a signed value gets sign-extended up to 64-bit.
+ */
+ RT_ZERO(u);
+ if (fFlags & RTSTR_F_VALSIGNED)
+ {
+ switch (s_aTypes[i].cb)
+ {
+ case sizeof(int8_t):
+ u.i64 = va_arg(*pArgs, /*int8_t*/int);
+ fFlags |= RTSTR_F_8BIT;
+ break;
+ case sizeof(int16_t):
+ u.i64 = va_arg(*pArgs, /*int16_t*/int);
+ fFlags |= RTSTR_F_16BIT;
+ break;
+ case sizeof(int32_t):
+ u.i64 = va_arg(*pArgs, int32_t);
+ fFlags |= RTSTR_F_32BIT;
+ break;
+ case sizeof(int64_t):
+ u.i64 = va_arg(*pArgs, int64_t);
+ fFlags |= RTSTR_F_64BIT;
+ break;
+ default:
+ AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
+ break;
+ }
+ }
+ else
+ {
+ switch (s_aTypes[i].cb)
+ {
+ case sizeof(uint8_t):
+ u.u8 = va_arg(*pArgs, /*uint8_t*/unsigned);
+ fFlags |= RTSTR_F_8BIT;
+ break;
+ case sizeof(uint16_t):
+ u.u16 = va_arg(*pArgs, /*uint16_t*/unsigned);
+ fFlags |= RTSTR_F_16BIT;
+ break;
+ case sizeof(uint32_t):
+ u.u32 = va_arg(*pArgs, uint32_t);
+ fFlags |= RTSTR_F_32BIT;
+ break;
+ case sizeof(uint64_t):
+ u.u64 = va_arg(*pArgs, uint64_t);
+ fFlags |= RTSTR_F_64BIT;
+ break;
+ case sizeof(RTFAR32):
+ u.fp32 = va_arg(*pArgs, RTFAR32);
+ break;
+ case sizeof(RTFAR64):
+ u.fp64 = va_arg(*pArgs, RTFAR64);
+ break;
+ default:
+ AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
+ break;
+ }
+ }
+
+#ifndef DEBUG
+ /*
+ * For now don't show the address.
+ */
+ if (fFlags & RTSTR_F_OBFUSCATE_PTR)
+ {
+ cch = rtStrFormatKernelAddress(szBuf, sizeof(szBuf), u.uR0Ptr, cchWidth, cchPrecision, fFlags);
+ return pfnOutput(pvArgOutput, szBuf, cch);
+ }
+#endif
+
+ /*
+ * Format the output.
+ */
+ switch (s_aTypes[i].enmFormat)
+ {
+ case RTSF_INT:
+ {
+ cch = RTStrFormatNumber(szBuf, u.u64, s_aTypes[i].u8Base, cchWidth, cchPrecision, fFlags);
+ break;
+ }
+
+ /* hex which defaults to max width. */
+ case RTSF_INTW:
+ {
+ Assert(s_aTypes[i].u8Base == 16);
+ if (cchWidth < 0)
+ {
+ cchWidth = s_aTypes[i].cb * 2 + (fFlags & RTSTR_F_SPECIAL ? 2 : 0);
+ fFlags |= RTSTR_F_ZEROPAD;
+ }
+ cch = RTStrFormatNumber(szBuf, u.u64, s_aTypes[i].u8Base, cchWidth, cchPrecision, fFlags);
+ break;
+ }
+
+ case RTSF_BOOL:
+ {
+ static const char s_szTrue[] = "true ";
+ static const char s_szFalse[] = "false";
+ if (u.u64 == 1)
+ return pfnOutput(pvArgOutput, s_szTrue, sizeof(s_szTrue) - 1);
+ if (u.u64 == 0)
+ return pfnOutput(pvArgOutput, s_szFalse, sizeof(s_szFalse) - 1);
+ /* invalid boolean value */
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "!%lld!", u.u64);
+ }
+
+ case RTSF_FP16:
+ {
+ fFlags &= ~(RTSTR_F_VALSIGNED | RTSTR_F_BIT_MASK | RTSTR_F_WIDTH | RTSTR_F_PRECISION | RTSTR_F_THOUSAND_SEP);
+ cch = RTStrFormatNumber(&szBuf[0], u.fp16.sel, 16, 4, -1, fFlags | RTSTR_F_16BIT);
+ Assert(cch == 4);
+ szBuf[4] = ':';
+ cch = RTStrFormatNumber(&szBuf[5], u.fp16.off, 16, 4, -1, fFlags | RTSTR_F_16BIT);
+ Assert(cch == 4);
+ cch = 4 + 1 + 4;
+ break;
+ }
+ case RTSF_FP32:
+ {
+ fFlags &= ~(RTSTR_F_VALSIGNED | RTSTR_F_BIT_MASK | RTSTR_F_WIDTH | RTSTR_F_PRECISION | RTSTR_F_THOUSAND_SEP);
+ cch = RTStrFormatNumber(&szBuf[0], u.fp32.sel, 16, 4, -1, fFlags | RTSTR_F_16BIT);
+ Assert(cch == 4);
+ szBuf[4] = ':';
+ cch = RTStrFormatNumber(&szBuf[5], u.fp32.off, 16, 8, -1, fFlags | RTSTR_F_32BIT);
+ Assert(cch == 8);
+ cch = 4 + 1 + 8;
+ break;
+ }
+ case RTSF_FP64:
+ {
+ fFlags &= ~(RTSTR_F_VALSIGNED | RTSTR_F_BIT_MASK | RTSTR_F_WIDTH | RTSTR_F_PRECISION | RTSTR_F_THOUSAND_SEP);
+ cch = RTStrFormatNumber(&szBuf[0], u.fp64.sel, 16, 4, -1, fFlags | RTSTR_F_16BIT);
+ Assert(cch == 4);
+ szBuf[4] = ':';
+ cch = RTStrFormatNumber(&szBuf[5], u.fp64.off, 16, 16, -1, fFlags | RTSTR_F_64BIT);
+ Assert(cch == 16);
+ cch = 4 + 1 + 16;
+ break;
+ }
+
+ case RTSF_IPV4:
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%u.%u.%u.%u",
+ u.Ipv4Addr.au8[0],
+ u.Ipv4Addr.au8[1],
+ u.Ipv4Addr.au8[2],
+ u.Ipv4Addr.au8[3]);
+
+ case RTSF_IPV6:
+ {
+ if (VALID_PTR(u.pIpv6Addr))
+ return rtstrFormatIPv6(pfnOutput, pvArgOutput, u.pIpv6Addr);
+ return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
+ }
+
+ case RTSF_MAC:
+ {
+ if (VALID_PTR(u.pMac))
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%02x:%02x:%02x:%02x:%02x:%02x",
+ u.pMac->au8[0],
+ u.pMac->au8[1],
+ u.pMac->au8[2],
+ u.pMac->au8[3],
+ u.pMac->au8[4],
+ u.pMac->au8[5]);
+ return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
+ }
+
+ case RTSF_NETADDR:
+ {
+ if (VALID_PTR(u.pNetAddr))
+ {
+ switch (u.pNetAddr->enmType)
+ {
+ case RTNETADDRTYPE_IPV4:
+ if (u.pNetAddr->uPort == RTNETADDR_PORT_NA)
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%u.%u.%u.%u",
+ u.pNetAddr->uAddr.IPv4.au8[0],
+ u.pNetAddr->uAddr.IPv4.au8[1],
+ u.pNetAddr->uAddr.IPv4.au8[2],
+ u.pNetAddr->uAddr.IPv4.au8[3]);
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%u.%u.%u.%u:%u",
+ u.pNetAddr->uAddr.IPv4.au8[0],
+ u.pNetAddr->uAddr.IPv4.au8[1],
+ u.pNetAddr->uAddr.IPv4.au8[2],
+ u.pNetAddr->uAddr.IPv4.au8[3],
+ u.pNetAddr->uPort);
+
+ case RTNETADDRTYPE_IPV6:
+ if (u.pNetAddr->uPort == RTNETADDR_PORT_NA)
+ return rtstrFormatIPv6(pfnOutput, pvArgOutput, &u.pNetAddr->uAddr.IPv6);
+
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "[%RTnaipv6]:%u",
+ &u.pNetAddr->uAddr.IPv6,
+ u.pNetAddr->uPort);
+
+ case RTNETADDRTYPE_MAC:
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%02x:%02x:%02x:%02x:%02x:%02x",
+ u.pNetAddr->uAddr.Mac.au8[0],
+ u.pNetAddr->uAddr.Mac.au8[1],
+ u.pNetAddr->uAddr.Mac.au8[2],
+ u.pNetAddr->uAddr.Mac.au8[3],
+ u.pNetAddr->uAddr.Mac.au8[4],
+ u.pNetAddr->uAddr.Mac.au8[5]);
+
+ default:
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "unsupported-netaddr-type=%u", u.pNetAddr->enmType);
+
+ }
+ }
+ return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
+ }
+
+ case RTSF_UUID:
+ {
+ if (VALID_PTR(u.pUuid))
+ {
+ /* cannot call RTUuidToStr because of GC/R0. */
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ RT_H2LE_U32(u.pUuid->Gen.u32TimeLow),
+ RT_H2LE_U16(u.pUuid->Gen.u16TimeMid),
+ RT_H2LE_U16(u.pUuid->Gen.u16TimeHiAndVersion),
+ u.pUuid->Gen.u8ClockSeqHiAndReserved,
+ u.pUuid->Gen.u8ClockSeqLow,
+ u.pUuid->Gen.au8Node[0],
+ u.pUuid->Gen.au8Node[1],
+ u.pUuid->Gen.au8Node[2],
+ u.pUuid->Gen.au8Node[3],
+ u.pUuid->Gen.au8Node[4],
+ u.pUuid->Gen.au8Node[5]);
+ }
+ return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
+ }
+
+ default:
+ AssertMsgFailed(("Internal error %d\n", s_aTypes[i].enmFormat));
+ return 0;
+ }
+
+ /*
+ * Finally, output the formatted string and return.
+ */
+ return pfnOutput(pvArgOutput, szBuf, cch);
+ }
+
+
+ /* Group 3 */
+
+ /*
+ * Base name printing, big endian UTF-16.
+ */
+ case 'b':
+ {
+ switch (*(*ppszFormat)++)
+ {
+ case 'n':
+ {
+ const char *pszLastSep;
+ const char *psz = pszLastSep = va_arg(*pArgs, const char *);
+ if (!VALID_PTR(psz))
+ return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
+
+ while ((ch = *psz) != '\0')
+ {
+ if (RTPATH_IS_SEP(ch))
+ {
+ do
+ psz++;
+ while ((ch = *psz) != '\0' && RTPATH_IS_SEP(ch));
+ if (!ch)
+ break;
+ pszLastSep = psz;
+ }
+ psz++;
+ }
+
+ return pfnOutput(pvArgOutput, pszLastSep, psz - pszLastSep);
+ }
+
+ /* %lRbs */
+ case 's':
+ if (chArgSize == 'l')
+ {
+ /* utf-16BE -> utf-8 */
+ int cchStr;
+ PCRTUTF16 pwszStr = va_arg(*pArgs, PRTUTF16);
+
+ if (RT_VALID_PTR(pwszStr))
+ {
+ cchStr = 0;
+ while (cchStr < cchPrecision && pwszStr[cchStr] != '\0')
+ cchStr++;
+ }
+ else
+ {
+ static RTUTF16 s_wszBigNull[] =
+ {
+ RT_H2BE_U16_C((uint16_t)'<'), RT_H2BE_U16_C((uint16_t)'N'), RT_H2BE_U16_C((uint16_t)'U'),
+ RT_H2BE_U16_C((uint16_t)'L'), RT_H2BE_U16_C((uint16_t)'L'), RT_H2BE_U16_C((uint16_t)'>'), '\0'
+ };
+ pwszStr = s_wszBigNull;
+ cchStr = RT_ELEMENTS(s_wszBigNull) - 1;
+ }
+
+ cch = 0;
+ if (!(fFlags & RTSTR_F_LEFT))
+ while (--cchWidth >= cchStr)
+ cch += pfnOutput(pvArgOutput, " ", 1);
+ cchWidth -= cchStr;
+ while (cchStr-- > 0)
+ {
+/** @todo \#ifndef IN_RC*/
+#ifdef IN_RING3
+ RTUNICP Cp = 0;
+ RTUtf16BigGetCpEx(&pwszStr, &Cp);
+ char *pszEnd = RTStrPutCp(szBuf, Cp);
+ *pszEnd = '\0';
+ cch += pfnOutput(pvArgOutput, szBuf, pszEnd - szBuf);
+#else
+ szBuf[0] = (char)(*pwszStr++ >> 8);
+ cch += pfnOutput(pvArgOutput, szBuf, 1);
+#endif
+ }
+ while (--cchWidth >= 0)
+ cch += pfnOutput(pvArgOutput, " ", 1);
+ return cch;
+ }
+ RT_FALL_THRU();
+
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ break;
+ }
+ break;
+ }
+
+
+ /*
+ * Pretty function / method name printing.
+ */
+ case 'f':
+ {
+ switch (*(*ppszFormat)++)
+ {
+ /*
+ * Pretty function / method name printing.
+ * This isn't 100% right (see classic signal prototype) and it assumes
+ * standardized names, but it'll do for today.
+ */
+ case 'n':
+ {
+ const char *pszStart;
+ const char *psz = pszStart = va_arg(*pArgs, const char *);
+ int cAngle = 0;
+
+ if (!VALID_PTR(psz))
+ return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
+
+ while ((ch = *psz) != '\0' && ch != '(')
+ {
+ if (RT_C_IS_BLANK(ch))
+ {
+ psz++;
+ while ((ch = *psz) != '\0' && (RT_C_IS_BLANK(ch) || ch == '('))
+ psz++;
+ if (ch && cAngle == 0)
+ pszStart = psz;
+ }
+ else if (ch == '(')
+ break;
+ else if (ch == '<')
+ {
+ cAngle++;
+ psz++;
+ }
+ else if (ch == '>')
+ {
+ cAngle--;
+ psz++;
+ }
+ else
+ psz++;
+ }
+
+ return pfnOutput(pvArgOutput, pszStart, psz - pszStart);
+ }
+
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ break;
+ }
+ break;
+ }
+
+
+ /*
+ * hex dumping, COM/XPCOM, human readable sizes.
+ */
+ case 'h':
+ {
+ ch = *(*ppszFormat)++;
+ switch (ch)
+ {
+ /*
+ * Hex stuff.
+ */
+ case 'x':
+ {
+ uint8_t *pu8 = va_arg(*pArgs, uint8_t *);
+ if (cchPrecision < 0)
+ cchPrecision = 16;
+ if (pu8)
+ {
+ switch (*(*ppszFormat)++)
+ {
+ /*
+ * Regular hex dump.
+ */
+ case 'd':
+ {
+ int off = 0;
+ cch = 0;
+
+ if (cchWidth <= 0)
+ cchWidth = 16;
+
+ while (off < cchPrecision)
+ {
+ int i;
+ cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%s%0*p %04x:", off ? "\n" : "", sizeof(pu8) * 2, (uintptr_t)pu8, off);
+ for (i = 0; i < cchWidth && off + i < cchPrecision ; i++)
+ cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ off + i < cchPrecision ? !(i & 7) && i ? "-%02x" : " %02x" : " ",
+ pu8[i]);
+ while (i++ < cchWidth)
+ cch += pfnOutput(pvArgOutput, " ", 3);
+
+ cch += pfnOutput(pvArgOutput, " ", 1);
+
+ for (i = 0; i < cchWidth && off + i < cchPrecision; i++)
+ {
+ uint8_t u8 = pu8[i];
+ cch += pfnOutput(pvArgOutput, u8 < 127 && u8 >= 32 ? (const char *)&u8 : ".", 1);
+ }
+
+ /* next */
+ pu8 += cchWidth;
+ off += cchWidth;
+ }
+ return cch;
+ }
+
+ /*
+ * Regular hex dump with dittoing.
+ */
+ case 'D':
+ {
+ int offEndDupCheck;
+ int cDuplicates = 0;
+ int off = 0;
+ cch = 0;
+
+ if (cchWidth <= 0)
+ cchWidth = 16;
+ offEndDupCheck = cchPrecision - cchWidth;
+
+ while (off < cchPrecision)
+ {
+ int i;
+ if ( off >= offEndDupCheck
+ || off <= 0
+ || memcmp(pu8, pu8 - cchWidth, cchWidth) != 0
+ || ( cDuplicates == 0
+ && ( off + cchWidth >= offEndDupCheck
+ || memcmp(pu8 + cchWidth, pu8, cchWidth) != 0)) )
+ {
+ if (cDuplicates > 0)
+ {
+ cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "\n%.*s **** <ditto x %u>",
+ sizeof(pu8) * 2, "****************", cDuplicates);
+ cDuplicates = 0;
+ }
+
+ cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ "%s%0*p %04x:", off ? "\n" : "", sizeof(pu8) * 2, (uintptr_t)pu8, off);
+ for (i = 0; i < cchWidth && off + i < cchPrecision ; i++)
+ cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
+ off + i < cchPrecision ? !(i & 7) && i
+ ? "-%02x" : " %02x" : " ",
+ pu8[i]);
+ while (i++ < cchWidth)
+ cch += pfnOutput(pvArgOutput, " ", 3);
+
+ cch += pfnOutput(pvArgOutput, " ", 1);
+
+ for (i = 0; i < cchWidth && off + i < cchPrecision; i++)
+ {
+ uint8_t u8 = pu8[i];
+ cch += pfnOutput(pvArgOutput, u8 < 127 && u8 >= 32 ? (const char *)&u8 : ".", 1);
+ }
+ }
+ else
+ cDuplicates++;
+
+ /* next */
+ pu8 += cchWidth;
+ off += cchWidth;
+ }
+ return cch;
+ }
+
+ /*
+ * Hex string.
+ */
+ case 's':
+ {
+ if (cchPrecision-- > 0)
+ {
+ cch = RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%02x", *pu8++);
+ for (; cchPrecision > 0; cchPrecision--, pu8++)
+ cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, " %02x", *pu8);
+ return cch;
+ }
+ break;
+ }
+
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ break;
+ }
+ }
+ else
+ return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
+ break;
+ }
+
+
+#ifdef IN_RING3
+ /*
+ * XPCOM / COM status code: %Rhrc, %Rhrf, %Rhra
+ * ASSUMES: If Windows Then COM else XPCOM.
+ */
+ case 'r':
+ {
+ uint32_t hrc = va_arg(*pArgs, uint32_t);
+ PCRTCOMERRMSG pMsg = RTErrCOMGet(hrc);
+ switch (*(*ppszFormat)++)
+ {
+ case 'c':
+ return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
+ case 'f':
+ return pfnOutput(pvArgOutput, pMsg->pszMsgFull,strlen(pMsg->pszMsgFull));
+ case 'a':
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X) - %s", pMsg->pszDefine, hrc, pMsg->pszMsgFull);
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+ break;
+ }
+#endif /* IN_RING3 */
+
+ case 'c':
+ case 'u':
+ {
+ unsigned i;
+ ssize_t cchBuf;
+ uint64_t uValue;
+ uint64_t uFraction = 0;
+ const char *pszPrefix = NULL;
+ unsigned cchFixedPart;
+ char ch2 = *(*ppszFormat)++;
+ AssertMsgReturn(ch2 == 'b' || ch2 == 'i', ("invalid type '%.10s'!\n", pszFormatOrg), 0);
+ uValue = va_arg(*pArgs, uint64_t);
+
+ if (!(fFlags & RTSTR_F_PRECISION))
+ cchPrecision = 1;
+ else if (cchPrecision > 3)
+ cchPrecision = 3;
+ else if (cchPrecision < 0)
+ cchPrecision = 0;
+
+ cchFixedPart = cchPrecision + (cchPrecision != 0) + (ch == 'c');
+
+ if (ch2 == 'b')
+ {
+ static const struct
+ {
+ const char *pszPrefix;
+ uint8_t cShift;
+ uint64_t cbMin;
+ uint64_t cbMinZeroPrecision;
+ } s_aUnits[] =
+ {
+ { "Ei", 60, _1E, _1E*2 },
+ { "Pi", 50, _1P, _1P*2 },
+ { "Ti", 40, _1T, _1T*2 },
+ { "Gi", 30, _1G, _1G64*2 },
+ { "Mi", 20, _1M, _1M*2 },
+ { "Ki", 10, _1K, _1K*2 },
+ };
+ for (i = 0; i < RT_ELEMENTS(s_aUnits); i++)
+ if ( uValue >= s_aUnits[i].cbMin
+ && (cchPrecision > 0 || uValue >= s_aUnits[i].cbMinZeroPrecision))
+ {
+ if (cchPrecision != 0)
+ {
+ uFraction = uValue & (RT_BIT_64(s_aUnits[i].cShift) - 1);
+ uFraction *= cchPrecision == 1 ? 10 : cchPrecision == 2 ? 100 : 1000;
+ uFraction >>= s_aUnits[i].cShift;
+ }
+ uValue >>= s_aUnits[i].cShift;
+ pszPrefix = s_aUnits[i].pszPrefix;
+ cchFixedPart += 2;
+ break;
+ }
+ }
+ else
+ {
+ static const struct
+ {
+ const char *pszPrefix;
+ uint64_t cbFactor;
+ uint64_t cbMinZeroPrecision;
+ } s_aUnits[] =
+ {
+ { "E", UINT64_C(1000000000000000000), UINT64_C(1010000000000000000), },
+ { "P", UINT64_C(1000000000000000), UINT64_C(1010000000000000), },
+ { "T", UINT64_C(1000000000000), UINT64_C(1010000000000), },
+ { "G", UINT64_C(1000000000), UINT64_C(1010000000), },
+ { "M", UINT64_C(1000000), UINT64_C(1010000), },
+ { "k", UINT64_C(1000), UINT64_C(1010), },
+ };
+ for (i = 0; i < RT_ELEMENTS(s_aUnits); i++)
+ if ( uValue >= s_aUnits[i].cbFactor
+ && (cchPrecision > 0 || uValue >= s_aUnits[i].cbMinZeroPrecision))
+ {
+ if (cchPrecision == 0)
+ uValue /= s_aUnits[i].cbFactor;
+ else
+ {
+ uFraction = uValue % s_aUnits[i].cbFactor;
+ uValue = uValue / s_aUnits[i].cbFactor;
+ uFraction *= cchPrecision == 1 ? 10 : cchPrecision == 2 ? 100 : 1000;
+ uFraction += s_aUnits[i].cbFactor >> 1;
+ uFraction /= s_aUnits[i].cbFactor;
+ }
+ pszPrefix = s_aUnits[i].pszPrefix;
+ cchFixedPart += 1;
+ break;
+ }
+ }
+
+ cchBuf = RTStrFormatU64(szBuf, sizeof(szBuf), uValue, 10, 0, 0, 0);
+ if (pszPrefix)
+ {
+ if (cchPrecision)
+ {
+ szBuf[cchBuf++] = '.';
+ cchBuf += RTStrFormatU64(&szBuf[cchBuf], sizeof(szBuf) - cchBuf, uFraction, 10, cchPrecision, 0,
+ RTSTR_F_ZEROPAD | RTSTR_F_WIDTH);
+ }
+ szBuf[cchBuf++] = *pszPrefix++;
+ if (*pszPrefix)
+ szBuf[cchBuf++] = *pszPrefix;
+ }
+ if (ch == 'c')
+ szBuf[cchBuf++] = 'B';
+ szBuf[cchBuf] = '\0';
+
+ cch = 0;
+ if ((fFlags & RTSTR_F_WIDTH) && !(fFlags & RTSTR_F_LEFT))
+ while (cchBuf < cchWidth)
+ {
+ cch += pfnOutput(pvArgOutput, fFlags & RTSTR_F_ZEROPAD ? "0" : " ", 1);
+ cchWidth--;
+ }
+ cch += pfnOutput(pvArgOutput, szBuf, cchBuf);
+ return cch;
+ }
+
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+
+ }
+ break;
+ }
+
+ /*
+ * iprt status code: %Rrc, %Rrs, %Rrf, %Rra.
+ */
+ case 'r':
+ {
+ int rc = va_arg(*pArgs, int);
+#ifdef IN_RING3 /* we don't want this anywhere else yet. */
+ PCRTSTATUSMSG pMsg = RTErrGet(rc);
+ switch (*(*ppszFormat)++)
+ {
+ case 'c':
+ return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
+ case 's':
+ return pfnOutput(pvArgOutput, pMsg->pszMsgShort, strlen(pMsg->pszMsgShort));
+ case 'f':
+ return pfnOutput(pvArgOutput, pMsg->pszMsgFull, strlen(pMsg->pszMsgFull));
+ case 'a':
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (%d) - %s", pMsg->pszDefine, rc, pMsg->pszMsgFull);
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+#else /* !IN_RING3 */
+ switch (*(*ppszFormat)++)
+ {
+ case 'c':
+ case 's':
+ case 'f':
+ case 'a':
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%d", rc);
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+#endif /* !IN_RING3 */
+ break;
+ }
+
+#if defined(IN_RING3)
+ /*
+ * Windows status code: %Rwc, %Rwf, %Rwa
+ */
+ case 'w':
+ {
+ long rc = va_arg(*pArgs, long);
+# if defined(RT_OS_WINDOWS)
+ PCRTWINERRMSG pMsg = RTErrWinGet(rc);
+# endif
+ switch (*(*ppszFormat)++)
+ {
+# if defined(RT_OS_WINDOWS)
+ case 'c':
+ return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
+ case 'f':
+ return pfnOutput(pvArgOutput, pMsg->pszMsgFull,strlen(pMsg->pszMsgFull));
+ case 'a':
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X) - %s", pMsg->pszDefine, rc, pMsg->pszMsgFull);
+# else
+ case 'c':
+ case 'f':
+ case 'a':
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "0x%08X", rc);
+# endif
+ default:
+ AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+ break;
+ }
+#endif /* IN_RING3 */
+
+ /*
+ * Group 4, structure dumpers.
+ */
+ case 'D':
+ {
+ /*
+ * Interpret the type.
+ */
+ typedef enum
+ {
+ RTST_TIMESPEC
+ } RTST;
+/** Set if it's a pointer */
+#define RTST_FLAGS_POINTER RT_BIT(0)
+ static const struct
+ {
+ uint8_t cch; /**< the length of the string. */
+ char sz[16-2]; /**< the part following 'R'. */
+ uint8_t cb; /**< the size of the argument. */
+ uint8_t fFlags; /**< RTST_FLAGS_* */
+ RTST enmType; /**< The structure type. */
+ }
+ /** Sorted array of types, looked up using binary search! */
+ s_aTypes[] =
+ {
+#define STRMEM(str) sizeof(str) - 1, str
+ { STRMEM("Dtimespec"), sizeof(PCRTTIMESPEC), RTST_FLAGS_POINTER, RTST_TIMESPEC},
+#undef STRMEM
+ };
+ const char *pszType = *ppszFormat - 1;
+ int iStart = 0;
+ int iEnd = RT_ELEMENTS(s_aTypes) - 1;
+ int i = RT_ELEMENTS(s_aTypes) / 2;
+
+ union
+ {
+ const void *pv;
+ uint64_t u64;
+ PCRTTIMESPEC pTimeSpec;
+ } u;
+
+ AssertMsg(!chArgSize, ("Not argument size '%c' for RT types! '%.10s'\n", chArgSize, pszFormatOrg));
+
+ /*
+ * Lookup the type - binary search.
+ */
+ for (;;)
+ {
+ int iDiff = strncmp(pszType, s_aTypes[i].sz, s_aTypes[i].cch);
+ if (!iDiff)
+ break;
+ if (iEnd == iStart)
+ {
+ AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+ if (iDiff < 0)
+ iEnd = i - 1;
+ else
+ iStart = i + 1;
+ if (iEnd < iStart)
+ {
+ AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
+ return 0;
+ }
+ i = iStart + (iEnd - iStart) / 2;
+ }
+ *ppszFormat += s_aTypes[i].cch - 1;
+
+ /*
+ * Fetch the argument.
+ */
+ u.u64 = 0;
+ switch (s_aTypes[i].cb)
+ {
+ case sizeof(const void *):
+ u.pv = va_arg(*pArgs, const void *);
+ break;
+ default:
+ AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
+ break;
+ }
+
+ /*
+ * If it's a pointer, we'll check if it's valid before going on.
+ */
+ if ((s_aTypes[i].fFlags & RTST_FLAGS_POINTER) && !VALID_PTR(u.pv))
+ return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
+
+ /*
+ * Format the output.
+ */
+ switch (s_aTypes[i].enmType)
+ {
+ case RTST_TIMESPEC:
+ return RTStrFormat(pfnOutput, pvArgOutput, NULL, NULL, "%'lld ns", RTTimeSpecGetNano(u.pTimeSpec));
+
+ default:
+ AssertMsgFailed(("Invalid/unhandled enmType=%d\n", s_aTypes[i].enmType));
+ break;
+ }
+ break;
+ }
+
+#ifdef IN_RING3
+
+ /*
+ * Group 5, XML / HTML, JSON and URI escapers.
+ */
+ case 'M':
+ {
+ char chWhat = (*ppszFormat)[0];
+ if (chWhat == 'a' || chWhat == 'e')
+ {
+ /* XML attributes and element values. */
+ bool fAttr = chWhat == 'a';
+ char chType = (*ppszFormat)[1];
+ *ppszFormat += 2;
+ switch (chType)
+ {
+ case 's':
+ {
+ static const char s_szElemEscape[] = "<>&\"'";
+ static const char s_szAttrEscape[] = "<>&\"\n\r"; /* more? */
+ const char * const pszEscape = fAttr ? s_szAttrEscape : s_szElemEscape;
+ size_t const cchEscape = (fAttr ? RT_ELEMENTS(s_szAttrEscape) : RT_ELEMENTS(s_szElemEscape)) - 1;
+ size_t cchOutput = 0;
+ const char *pszStr = va_arg(*pArgs, char *);
+ ssize_t cchStr;
+ ssize_t offCur;
+ ssize_t offLast;
+
+ if (!VALID_PTR(pszStr))
+ pszStr = "<NULL>";
+ cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
+
+ if (fAttr)
+ cchOutput += pfnOutput(pvArgOutput, "\"", 1);
+ if (!(fFlags & RTSTR_F_LEFT))
+ while (--cchWidth >= cchStr)
+ cchOutput += pfnOutput(pvArgOutput, " ", 1);
+
+ offLast = offCur = 0;
+ while (offCur < cchStr)
+ {
+ if (memchr(pszEscape, pszStr[offCur], cchEscape))
+ {
+ if (offLast < offCur)
+ cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
+ switch (pszStr[offCur])
+ {
+ case '<': cchOutput += pfnOutput(pvArgOutput, "&lt;", 4); break;
+ case '>': cchOutput += pfnOutput(pvArgOutput, "&gt;", 4); break;
+ case '&': cchOutput += pfnOutput(pvArgOutput, "&amp;", 5); break;
+ case '\'': cchOutput += pfnOutput(pvArgOutput, "&apos;", 6); break;
+ case '"': cchOutput += pfnOutput(pvArgOutput, "&quot;", 6); break;
+ case '\n': cchOutput += pfnOutput(pvArgOutput, "&#xA;", 5); break;
+ case '\r': cchOutput += pfnOutput(pvArgOutput, "&#xD;", 5); break;
+ default:
+ AssertFailed();
+ }
+ offLast = offCur + 1;
+ }
+ offCur++;
+ }
+ if (offLast < offCur)
+ cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
+
+ while (--cchWidth >= cchStr)
+ cchOutput += pfnOutput(pvArgOutput, " ", 1);
+ if (fAttr)
+ cchOutput += pfnOutput(pvArgOutput, "\"", 1);
+ return cchOutput;
+ }
+
+ default:
+ AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
+ }
+ }
+ else if (chWhat == 'j')
+ {
+ /* JSON string escaping. */
+ char const chType = (*ppszFormat)[1];
+ *ppszFormat += 2;
+ switch (chType)
+ {
+ case 's':
+ {
+ const char *pszStr = va_arg(*pArgs, char *);
+ size_t cchOutput;
+ ssize_t cchStr;
+ ssize_t offCur;
+ ssize_t offLast;
+
+ if (!VALID_PTR(pszStr))
+ pszStr = "<NULL>";
+ cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
+
+ cchOutput = pfnOutput(pvArgOutput, "\"", 1);
+ if (!(fFlags & RTSTR_F_LEFT))
+ while (--cchWidth >= cchStr)
+ cchOutput += pfnOutput(pvArgOutput, " ", 1);
+
+ offLast = offCur = 0;
+ while (offCur < cchStr)
+ {
+ unsigned int const uch = pszStr[offCur];
+ if ( uch >= 0x5d
+ || (uch >= 0x20 && uch != 0x22 && uch != 0x5c))
+ offCur++;
+ else
+ {
+ if (offLast < offCur)
+ cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
+ switch ((char)uch)
+ {
+ case '"': cchOutput += pfnOutput(pvArgOutput, "\\\"", 2); break;
+ case '\\': cchOutput += pfnOutput(pvArgOutput, "\\\\", 2); break;
+ case '/': cchOutput += pfnOutput(pvArgOutput, "\\/", 2); break;
+ case '\b': cchOutput += pfnOutput(pvArgOutput, "\\b", 2); break;
+ case '\f': cchOutput += pfnOutput(pvArgOutput, "\\f", 2); break;
+ case '\n': cchOutput += pfnOutput(pvArgOutput, "\\n", 2); break;
+ case '\t': cchOutput += pfnOutput(pvArgOutput, "\\t", 2); break;
+ default:
+ {
+ RTUNICP uc = 0xfffd; /* replacement character */
+ const char *pszCur = &pszStr[offCur];
+ int rc = RTStrGetCpEx(&pszCur, &uc);
+ if (RT_SUCCESS(rc))
+ offCur += pszCur - &pszStr[offCur] - 1;
+ if (uc >= 0xfffe)
+ uc = 0xfffd; /* replacement character */
+ szBuf[0] = '\\';
+ szBuf[1] = 'u';
+ szBuf[2] = g_szHexDigits[(uc >> 12) & 0xf];
+ szBuf[3] = g_szHexDigits[(uc >> 8) & 0xf];
+ szBuf[4] = g_szHexDigits[(uc >> 4) & 0xf];
+ szBuf[5] = g_szHexDigits[ uc & 0xf];
+ szBuf[6] = '\0';
+ cchOutput += pfnOutput(pvArgOutput, szBuf, 6);
+ break;
+ }
+ }
+ offLast = ++offCur;
+ }
+ }
+ if (offLast < offCur)
+ cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
+
+ while (--cchWidth >= cchStr)
+ cchOutput += pfnOutput(pvArgOutput, " ", 1);
+ cchOutput += pfnOutput(pvArgOutput, "\"", 1);
+ return cchOutput;
+ }
+
+ default:
+ AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
+ }
+ }
+ else if (chWhat == 'p')
+ {
+ /* Percent encoded string (RTC-3986). */
+ char const chVariant = (*ppszFormat)[1];
+ char const chAddSafe = chVariant == 'p' ? '/'
+ : chVariant == 'q' ? '+' /* '+' in queries is problematic, so no escape. */
+ : '~' /* whatever */;
+ size_t cchOutput = 0;
+ const char *pszStr = va_arg(*pArgs, char *);
+ ssize_t cchStr;
+ ssize_t offCur;
+ ssize_t offLast;
+
+ *ppszFormat += 2;
+ AssertMsgBreak(chVariant == 'a' || chVariant == 'p' || chVariant == 'q' || chVariant == 'f',
+ ("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
+
+ if (!VALID_PTR(pszStr))
+ pszStr = "<NULL>";
+ cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
+
+ if (!(fFlags & RTSTR_F_LEFT))
+ while (--cchWidth >= cchStr)
+ cchOutput += pfnOutput(pvArgOutput, "%20", 3);
+
+ offLast = offCur = 0;
+ while (offCur < cchStr)
+ {
+ ch = pszStr[offCur];
+ if ( RT_C_IS_ALPHA(ch)
+ || RT_C_IS_DIGIT(ch)
+ || ch == '-'
+ || ch == '.'
+ || ch == '_'
+ || ch == '~'
+ || ch == chAddSafe)
+ offCur++;
+ else
+ {
+ if (offLast < offCur)
+ cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
+ if (ch != ' ' || chVariant != 'f')
+ {
+ szBuf[0] = '%';
+ szBuf[1] = g_szHexDigitsUpper[((uint8_t)ch >> 4) & 0xf];
+ szBuf[2] = g_szHexDigitsUpper[(uint8_t)ch & 0xf];
+ szBuf[3] = '\0';
+ cchOutput += pfnOutput(pvArgOutput, szBuf, 3);
+ }
+ else
+ cchOutput += pfnOutput(pvArgOutput, "+", 1);
+ offLast = ++offCur;
+ }
+ }
+ if (offLast < offCur)
+ cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
+
+ while (--cchWidth >= cchStr)
+ cchOutput += pfnOutput(pvArgOutput, "%20", 3);
+ }
+ else
+ AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
+ break;
+ }
+
+#endif /* IN_RING3 */
+
+ /*
+ * Groups 6 - CPU Architecture Register Formatters.
+ * "%RAarch[reg]"
+ */
+ case 'A':
+ {
+ char const * const pszArch = *ppszFormat;
+ const char *pszReg = pszArch;
+ size_t cchOutput = 0;
+ int cPrinted = 0;
+ size_t cchReg;
+
+ /* Parse out the */
+ while ((ch = *pszReg++) && ch != '[')
+ { /* nothing */ }
+ AssertMsgBreak(ch == '[', ("Malformed IPRT architecture register format type '%.10s'!\n", pszFormatOrg));
+
+ cchReg = 0;
+ while ((ch = pszReg[cchReg]) && ch != ']')
+ cchReg++;
+ AssertMsgBreak(ch == ']', ("Malformed IPRT architecture register format type '%.10s'!\n", pszFormatOrg));
+
+ *ppszFormat = &pszReg[cchReg + 1];
+
+
+#define REG_EQUALS(a_szReg) (sizeof(a_szReg) - 1 == cchReg && !strncmp(a_szReg, pszReg, sizeof(a_szReg) - 1))
+#define REG_OUT_BIT(a_uVal, a_fBitMask, a_szName) \
+ do { \
+ if ((a_uVal) & (a_fBitMask)) \
+ { \
+ if (!cPrinted++) \
+ cchOutput += pfnOutput(pvArgOutput, "{" a_szName, sizeof(a_szName)); \
+ else \
+ cchOutput += pfnOutput(pvArgOutput, "," a_szName, sizeof(a_szName)); \
+ (a_uVal) &= ~(a_fBitMask); \
+ } \
+ } while (0)
+#define REG_OUT_CLOSE(a_uVal) \
+ do { \
+ if ((a_uVal)) \
+ { \
+ cchOutput += pfnOutput(pvArgOutput, !cPrinted ? "{unkn=" : ",unkn=", 6); \
+ cch = RTStrFormatNumber(&szBuf[0], (a_uVal), 16, 1, -1, fFlags); \
+ cchOutput += pfnOutput(pvArgOutput, szBuf, cch); \
+ cPrinted++; \
+ } \
+ if (cPrinted) \
+ cchOutput += pfnOutput(pvArgOutput, "}", 1); \
+ } while (0)
+
+
+ if (0)
+ { /* dummy */ }
+#ifdef STRFORMAT_WITH_X86
+ /*
+ * X86 & AMD64.
+ */
+ else if ( pszReg - pszArch == 3 + 1
+ && pszArch[0] == 'x'
+ && pszArch[1] == '8'
+ && pszArch[2] == '6')
+ {
+ if (REG_EQUALS("cr0"))
+ {
+ uint64_t cr0 = va_arg(*pArgs, uint64_t);
+ fFlags |= RTSTR_F_64BIT;
+ cch = RTStrFormatNumber(&szBuf[0], cr0, 16, 8, -1, fFlags | RTSTR_F_ZEROPAD);
+ cchOutput += pfnOutput(pvArgOutput, szBuf, cch);
+ REG_OUT_BIT(cr0, X86_CR0_PE, "PE");
+ REG_OUT_BIT(cr0, X86_CR0_MP, "MP");
+ REG_OUT_BIT(cr0, X86_CR0_EM, "EM");
+ REG_OUT_BIT(cr0, X86_CR0_TS, "DE");
+ REG_OUT_BIT(cr0, X86_CR0_ET, "ET");
+ REG_OUT_BIT(cr0, X86_CR0_NE, "NE");
+ REG_OUT_BIT(cr0, X86_CR0_WP, "WP");
+ REG_OUT_BIT(cr0, X86_CR0_AM, "AM");
+ REG_OUT_BIT(cr0, X86_CR0_NW, "NW");
+ REG_OUT_BIT(cr0, X86_CR0_CD, "CD");
+ REG_OUT_BIT(cr0, X86_CR0_PG, "PG");
+ REG_OUT_CLOSE(cr0);
+ }
+ else if (REG_EQUALS("cr4"))
+ {
+ uint64_t cr4 = va_arg(*pArgs, uint64_t);
+ fFlags |= RTSTR_F_64BIT;
+ cch = RTStrFormatNumber(&szBuf[0], cr4, 16, 8, -1, fFlags | RTSTR_F_ZEROPAD);
+ cchOutput += pfnOutput(pvArgOutput, szBuf, cch);
+ REG_OUT_BIT(cr4, X86_CR4_VME, "VME");
+ REG_OUT_BIT(cr4, X86_CR4_PVI, "PVI");
+ REG_OUT_BIT(cr4, X86_CR4_TSD, "TSD");
+ REG_OUT_BIT(cr4, X86_CR4_DE, "DE");
+ REG_OUT_BIT(cr4, X86_CR4_PSE, "PSE");
+ REG_OUT_BIT(cr4, X86_CR4_PAE, "PAE");
+ REG_OUT_BIT(cr4, X86_CR4_MCE, "MCE");
+ REG_OUT_BIT(cr4, X86_CR4_PGE, "PGE");
+ REG_OUT_BIT(cr4, X86_CR4_PCE, "PCE");
+ REG_OUT_BIT(cr4, X86_CR4_OSFXSR, "OSFXSR");
+ REG_OUT_BIT(cr4, X86_CR4_OSXMMEEXCPT, "OSXMMEEXCPT");
+ REG_OUT_BIT(cr4, X86_CR4_VMXE, "VMXE");
+ REG_OUT_BIT(cr4, X86_CR4_SMXE, "SMXE");
+ REG_OUT_BIT(cr4, X86_CR4_PCIDE, "PCIDE");
+ REG_OUT_BIT(cr4, X86_CR4_OSXSAVE, "OSXSAVE");
+ REG_OUT_BIT(cr4, X86_CR4_SMEP, "SMEP");
+ REG_OUT_BIT(cr4, X86_CR4_SMAP, "SMAP");
+ REG_OUT_CLOSE(cr4);
+ }
+ else
+ AssertMsgFailed(("Unknown x86 register specified in '%.10s'!\n", pszFormatOrg));
+ }
+#endif
+ else
+ AssertMsgFailed(("Unknown architecture specified in '%.10s'!\n", pszFormatOrg));
+#undef REG_OUT_BIT
+#undef REG_OUT_CLOSE
+#undef REG_EQUALS
+ return cchOutput;
+ }
+
+ /*
+ * Invalid/Unknown. Bitch about it.
+ */
+ default:
+ AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
+ break;
+ }
+ }
+ else
+ AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
+
+ NOREF(pszFormatOrg);
+ return 0;
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-19 07:52:28 +0000