strformatrt.cpp@ 84054

Last change on this file since 84054 was 84054, checked in by vboxsync, 5 years ago
IPRT,++: Apply bldprog-strtab.h and friends to the IPRT status message database (errmsg.cpp) to reduce size. The interface (RTErrMsg*) has been reworked as we no longer have C-strings in the database, but 'compressed' string w/o zero terminators. bugref:9726
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 78.2 KB

Line
1	/* $Id: strformatrt.cpp 84054 2020-04-28 16:05:00Z vboxsync $ */
2	/** @file
3	* IPRT - IPRT String Formatter Extensions.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_STRING
32	#include <iprt/string.h>
33	#ifndef RT_NO_EXPORT_SYMBOL
34	# define RT_NO_EXPORT_SYMBOL /* don't slurp <linux/module.h> which then again
35	slurps arch-specific headers defining symbols */
36	#endif
37	#include "internal/iprt.h"
38
39	#include <iprt/log.h>
40	#include <iprt/assert.h>
41	#include <iprt/string.h>
42	#include <iprt/stdarg.h>
43	#ifdef IN_RING3
44	# include <iprt/errcore.h>
45	# include <iprt/thread.h>
46	# include <iprt/utf16.h>
47	#endif
48	#include <iprt/ctype.h>
49	#include <iprt/time.h>
50	#include <iprt/net.h>
51	#include <iprt/path.h>
52	#include <iprt/asm.h>
53	#define STRFORMAT_WITH_X86
54	#ifdef STRFORMAT_WITH_X86
55	# include <iprt/x86.h>
56	#endif
57	#include "internal/string.h"
58
59
60	/*********************************************************************************************************************************
61	* Global Variables *
62	*********************************************************************************************************************************/
63	static char g_szHexDigits[17] = "0123456789abcdef";
64	#ifdef IN_RING3
65	static char g_szHexDigitsUpper[17] = "0123456789ABCDEF";
66	#endif
67
68
69	/**
70	* Helper that formats a 16-bit hex word in a IPv6 address.
71	*
72	* @returns Length in chars.
73	* @param pszDst The output buffer. Written from the start.
74	* @param uWord The word to format as hex.
75	*/
76	static size_t rtstrFormatIPv6HexWord(char *pszDst, uint16_t uWord)
77	{
78	size_t off;
79	uint16_t cDigits;
80
81	if (uWord & UINT16_C(0xff00))
82	cDigits = uWord & UINT16_C(0xf000) ? 4 : 3;
83	else
84	cDigits = uWord & UINT16_C(0x00f0) ? 2 : 1;
85
86	off = 0;
87	switch (cDigits)
88	{
89	case 4: pszDst[off++] = g_szHexDigits[(uWord >> 12) & 0xf]; RT_FALL_THRU();
90	case 3: pszDst[off++] = g_szHexDigits[(uWord >> 8) & 0xf]; RT_FALL_THRU();
91	case 2: pszDst[off++] = g_szHexDigits[(uWord >> 4) & 0xf]; RT_FALL_THRU();
92	case 1: pszDst[off++] = g_szHexDigits[(uWord >> 0) & 0xf];
93	break;
94	}
95	pszDst[off] = '\0';
96	return off;
97	}
98
99
100	/**
101	* Helper function to format IPv6 address according to RFC 5952.
102	*
103	* @returns The number of bytes formatted.
104	* @param pfnOutput Pointer to output function.
105	* @param pvArgOutput Argument for the output function.
106	* @param pIpv6Addr IPv6 address
107	*/
108	static size_t rtstrFormatIPv6(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, PCRTNETADDRIPV6 pIpv6Addr)
109	{
110	size_t cch; /* result */
111	bool fEmbeddedIpv4;
112	size_t cwHexPart;
113	size_t cwLongestZeroRun;
114	size_t iLongestZeroStart;
115	size_t idx;
116	char szHexWord[8];
117
118	Assert(pIpv6Addr != NULL);
119
120	/*
121	* Check for embedded IPv4 address.
122	*
123	* IPv4-compatible - ::11.22.33.44 (obsolete)
124	* IPv4-mapped - ::ffff:11.22.33.44
125	* IPv4-translated - ::ffff:0:11.22.33.44 (RFC 2765)
126	*/
127	fEmbeddedIpv4 = false;
128	cwHexPart = RT_ELEMENTS(pIpv6Addr->au16);
129	if ( pIpv6Addr->au64[0] == 0
130	&& ( ( pIpv6Addr->au32[2] == 0
131	&& pIpv6Addr->au32[3] != 0
132	&& pIpv6Addr->au32[3] != RT_H2BE_U32_C(1) )
133	\|\| pIpv6Addr->au32[2] == RT_H2BE_U32_C(0x0000ffff)
134	\|\| pIpv6Addr->au32[2] == RT_H2BE_U32_C(0xffff0000) ) )
135	{
136	fEmbeddedIpv4 = true;
137	cwHexPart -= 2;
138	}
139
140	/*
141	* Find the longest sequences of two or more zero words.
142	*/
143	cwLongestZeroRun = 0;
144	iLongestZeroStart = 0;
145	for (idx = 0; idx < cwHexPart; idx++)
146	if (pIpv6Addr->au16[idx] == 0)
147	{
148	size_t iZeroStart = idx;
149	size_t cwZeroRun;
150	do
151	idx++;
152	while (idx < cwHexPart && pIpv6Addr->au16[idx] == 0);
153	cwZeroRun = idx - iZeroStart;
154	if (cwZeroRun > 1 && cwZeroRun > cwLongestZeroRun)
155	{
156	cwLongestZeroRun = cwZeroRun;
157	iLongestZeroStart = iZeroStart;
158	if (cwZeroRun >= cwHexPart - idx)
159	break;
160	}
161	}
162
163	/*
164	* Do the formatting.
165	*/
166	cch = 0;
167	if (cwLongestZeroRun == 0)
168	{
169	for (idx = 0; idx < cwHexPart; ++idx)
170	{
171	if (idx > 0)
172	cch += pfnOutput(pvArgOutput, ":", 1);
173	cch += pfnOutput(pvArgOutput, szHexWord, rtstrFormatIPv6HexWord(szHexWord, RT_BE2H_U16(pIpv6Addr->au16[idx])));
174	}
175
176	if (fEmbeddedIpv4)
177	cch += pfnOutput(pvArgOutput, ":", 1);
178	}
179	else
180	{
181	const size_t iLongestZeroEnd = iLongestZeroStart + cwLongestZeroRun;
182
183	if (iLongestZeroStart == 0)
184	cch += pfnOutput(pvArgOutput, ":", 1);
185	else
186	for (idx = 0; idx < iLongestZeroStart; ++idx)
187	{
188	cch += pfnOutput(pvArgOutput, szHexWord, rtstrFormatIPv6HexWord(szHexWord, RT_BE2H_U16(pIpv6Addr->au16[idx])));
189	cch += pfnOutput(pvArgOutput, ":", 1);
190	}
191
192	if (iLongestZeroEnd == cwHexPart)
193	cch += pfnOutput(pvArgOutput, ":", 1);
194	else
195	{
196	for (idx = iLongestZeroEnd; idx < cwHexPart; ++idx)
197	{
198	cch += pfnOutput(pvArgOutput, ":", 1);
199	cch += pfnOutput(pvArgOutput, szHexWord, rtstrFormatIPv6HexWord(szHexWord, RT_BE2H_U16(pIpv6Addr->au16[idx])));
200	}
201
202	if (fEmbeddedIpv4)
203	cch += pfnOutput(pvArgOutput, ":", 1);
204	}
205	}
206
207	if (fEmbeddedIpv4)
208	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
209	"%u.%u.%u.%u",
210	pIpv6Addr->au8[12],
211	pIpv6Addr->au8[13],
212	pIpv6Addr->au8[14],
213	pIpv6Addr->au8[15]);
214
215	return cch;
216	}
217
218
219	/**
220	* Callback to format iprt formatting extentions.
221	* See @ref pg_rt_str_format for a reference on the format types.
222	*
223	* @returns The number of bytes formatted.
224	* @param pfnOutput Pointer to output function.
225	* @param pvArgOutput Argument for the output function.
226	* @param ppszFormat Pointer to the format string pointer. Advance this till the char
227	* after the format specifier.
228	* @param pArgs Pointer to the argument list. Use this to fetch the arguments.
229	* @param cchWidth Format Width. -1 if not specified.
230	* @param cchPrecision Format Precision. -1 if not specified.
231	* @param fFlags Flags (RTSTR_NTFS_*).
232	* @param chArgSize The argument size specifier, 'l' or 'L'.
233	*/
234	DECLHIDDEN(size_t) rtstrFormatRt(PFNRTSTROUTPUT pfnOutput, void pvArgOutput, const char ppszFormat, va_list pArgs,
235	int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize)
236	{
237	const char pszFormatOrg = ppszFormat;
238	char ch = (ppszFormat)++;
239	size_t cch;
240	char szBuf[80];
241
242	if (ch == 'R')
243	{
244	ch = (ppszFormat)++;
245	switch (ch)
246	{
247	/*
248	* Groups 1 and 2.
249	*/
250	case 'T':
251	case 'G':
252	case 'H':
253	case 'R':
254	case 'C':
255	case 'I':
256	case 'X':
257	case 'U':
258	case 'K':
259	{
260	/*
261	* Interpret the type.
262	*/
263	typedef enum
264	{
265	RTSF_INT,
266	RTSF_INTW,
267	RTSF_BOOL,
268	RTSF_FP16,
269	RTSF_FP32,
270	RTSF_FP64,
271	RTSF_IPV4,
272	RTSF_IPV6,
273	RTSF_MAC,
274	RTSF_NETADDR,
275	RTSF_UUID,
276	RTSF_ERRINFO,
277	RTSF_ERRINFO_MSG_ONLY
278	} RTSF;
279	static const struct
280	{
281	uint8_t cch; /*< the length of the string. /
282	char sz[10]; /*< the part following 'R'. /
283	uint8_t cb; /*< the size of the type. /
284	uint8_t u8Base; /*< the size of the type. /
285	RTSF enmFormat; /*< The way to format it. /
286	uint16_t fFlags; /*< additional RTSTR_F_ flags. */
287	}
288	/** Sorted array of types, looked up using binary search! */
289	s_aTypes[] =
290	{
291	#define STRMEM(str) sizeof(str) - 1, str
292	{ STRMEM("Ci"), sizeof(RTINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
293	{ STRMEM("Cp"), sizeof(RTCCPHYS), 16, RTSF_INTW, 0 },
294	{ STRMEM("Cr"), sizeof(RTCCUINTREG), 16, RTSF_INTW, 0 },
295	{ STRMEM("Cu"), sizeof(RTUINT), 10, RTSF_INT, 0 },
296	{ STRMEM("Cv"), sizeof(void *), 16, RTSF_INTW, 0 },
297	{ STRMEM("Cx"), sizeof(RTUINT), 16, RTSF_INT, 0 },
298	{ STRMEM("Gi"), sizeof(RTGCINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
299	{ STRMEM("Gp"), sizeof(RTGCPHYS), 16, RTSF_INTW, 0 },
300	{ STRMEM("Gr"), sizeof(RTGCUINTREG), 16, RTSF_INTW, 0 },
301	{ STRMEM("Gu"), sizeof(RTGCUINT), 10, RTSF_INT, 0 },
302	{ STRMEM("Gv"), sizeof(RTGCPTR), 16, RTSF_INTW, 0 },
303	{ STRMEM("Gx"), sizeof(RTGCUINT), 16, RTSF_INT, 0 },
304	{ STRMEM("Hi"), sizeof(RTHCINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
305	{ STRMEM("Hp"), sizeof(RTHCPHYS), 16, RTSF_INTW, 0 },
306	{ STRMEM("Hr"), sizeof(RTHCUINTREG), 16, RTSF_INTW, 0 },
307	{ STRMEM("Hu"), sizeof(RTHCUINT), 10, RTSF_INT, 0 },
308	{ STRMEM("Hv"), sizeof(RTHCPTR), 16, RTSF_INTW, 0 },
309	{ STRMEM("Hx"), sizeof(RTHCUINT), 16, RTSF_INT, 0 },
310	{ STRMEM("I16"), sizeof(int16_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
311	{ STRMEM("I32"), sizeof(int32_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
312	{ STRMEM("I64"), sizeof(int64_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
313	{ STRMEM("I8"), sizeof(int8_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
314	{ STRMEM("Kv"), sizeof(RTHCPTR), 16, RTSF_INT, RTSTR_F_OBFUSCATE_PTR },
315	{ STRMEM("Rv"), sizeof(RTRCPTR), 16, RTSF_INTW, 0 },
316	{ STRMEM("Tbool"), sizeof(bool), 10, RTSF_BOOL, 0 },
317	{ STRMEM("Teic"), sizeof(PCRTERRINFO), 16, RTSF_ERRINFO, 0 },
318	{ STRMEM("Teim"), sizeof(PCRTERRINFO), 16, RTSF_ERRINFO_MSG_ONLY, 0 },
319	{ STRMEM("Tfile"), sizeof(RTFILE), 10, RTSF_INT, 0 },
320	{ STRMEM("Tfmode"), sizeof(RTFMODE), 16, RTSF_INTW, 0 },
321	{ STRMEM("Tfoff"), sizeof(RTFOFF), 10, RTSF_INT, RTSTR_F_VALSIGNED },
322	{ STRMEM("Tfp16"), sizeof(RTFAR16), 16, RTSF_FP16, RTSTR_F_ZEROPAD },
323	{ STRMEM("Tfp32"), sizeof(RTFAR32), 16, RTSF_FP32, RTSTR_F_ZEROPAD },
324	{ STRMEM("Tfp64"), sizeof(RTFAR64), 16, RTSF_FP64, RTSTR_F_ZEROPAD },
325	{ STRMEM("Tgid"), sizeof(RTGID), 10, RTSF_INT, RTSTR_F_VALSIGNED },
326	{ STRMEM("Tino"), sizeof(RTINODE), 16, RTSF_INTW, 0 },
327	{ STRMEM("Tint"), sizeof(RTINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
328	{ STRMEM("Tiop"), sizeof(RTIOPORT), 16, RTSF_INTW, 0 },
329	{ STRMEM("Tldrm"), sizeof(RTLDRMOD), 16, RTSF_INTW, 0 },
330	{ STRMEM("Tmac"), sizeof(PCRTMAC), 16, RTSF_MAC, 0 },
331	{ STRMEM("Tnaddr"), sizeof(PCRTNETADDR), 10, RTSF_NETADDR,0 },
332	{ STRMEM("Tnaipv4"), sizeof(RTNETADDRIPV4), 10, RTSF_IPV4, 0 },
333	{ STRMEM("Tnaipv6"), sizeof(PCRTNETADDRIPV6),16, RTSF_IPV6, 0 },
334	{ STRMEM("Tnthrd"), sizeof(RTNATIVETHREAD), 16, RTSF_INTW, 0 },
335	{ STRMEM("Tproc"), sizeof(RTPROCESS), 16, RTSF_INTW, 0 },
336	{ STRMEM("Tptr"), sizeof(RTUINTPTR), 16, RTSF_INTW, 0 },
337	{ STRMEM("Treg"), sizeof(RTCCUINTREG), 16, RTSF_INTW, 0 },
338	{ STRMEM("Tsel"), sizeof(RTSEL), 16, RTSF_INTW, 0 },
339	{ STRMEM("Tsem"), sizeof(RTSEMEVENT), 16, RTSF_INTW, 0 },
340	{ STRMEM("Tsock"), sizeof(RTSOCKET), 10, RTSF_INT, 0 },
341	{ STRMEM("Tthrd"), sizeof(RTTHREAD), 16, RTSF_INTW, 0 },
342	{ STRMEM("Tuid"), sizeof(RTUID), 10, RTSF_INT, RTSTR_F_VALSIGNED },
343	{ STRMEM("Tuint"), sizeof(RTUINT), 10, RTSF_INT, 0 },
344	{ STRMEM("Tunicp"), sizeof(RTUNICP), 16, RTSF_INTW, RTSTR_F_ZEROPAD },
345	{ STRMEM("Tutf16"), sizeof(RTUTF16), 16, RTSF_INTW, RTSTR_F_ZEROPAD },
346	{ STRMEM("Tuuid"), sizeof(PCRTUUID), 16, RTSF_UUID, 0 },
347	{ STRMEM("Txint"), sizeof(RTUINT), 16, RTSF_INT, 0 },
348	{ STRMEM("U16"), sizeof(uint16_t), 10, RTSF_INT, 0 },
349	{ STRMEM("U32"), sizeof(uint32_t), 10, RTSF_INT, 0 },
350	{ STRMEM("U64"), sizeof(uint64_t), 10, RTSF_INT, 0 },
351	{ STRMEM("U8"), sizeof(uint8_t), 10, RTSF_INT, 0 },
352	{ STRMEM("X16"), sizeof(uint16_t), 16, RTSF_INT, 0 },
353	{ STRMEM("X32"), sizeof(uint32_t), 16, RTSF_INT, 0 },
354	{ STRMEM("X64"), sizeof(uint64_t), 16, RTSF_INT, 0 },
355	{ STRMEM("X8"), sizeof(uint8_t), 16, RTSF_INT, 0 },
356	#undef STRMEM
357	};
358	static const char s_szNull[] = "<NULL>";
359
360	const char pszType = ppszFormat - 1;
361	int iStart = 0;
362	int iEnd = RT_ELEMENTS(s_aTypes) - 1;
363	int i = RT_ELEMENTS(s_aTypes) / 2;
364
365	union
366	{
367	uint8_t u8;
368	uint16_t u16;
369	uint32_t u32;
370	uint64_t u64;
371	int8_t i8;
372	int16_t i16;
373	int32_t i32;
374	int64_t i64;
375	RTR0INTPTR uR0Ptr;
376	RTFAR16 fp16;
377	RTFAR32 fp32;
378	RTFAR64 fp64;
379	bool fBool;
380	PCRTMAC pMac;
381	RTNETADDRIPV4 Ipv4Addr;
382	PCRTNETADDRIPV6 pIpv6Addr;
383	PCRTNETADDR pNetAddr;
384	PCRTUUID pUuid;
385	PCRTERRINFO pErrInfo;
386	} u;
387
388	AssertMsg(!chArgSize, ("Not argument size '%c' for RT types! '%.10s'\n", chArgSize, pszFormatOrg));
389	RT_NOREF_PV(chArgSize);
390
391	/*
392	* Lookup the type - binary search.
393	*/
394	for (;;)
395	{
396	int iDiff = strncmp(pszType, s_aTypes[i].sz, s_aTypes[i].cch);
397	if (!iDiff)
398	break;
399	if (iEnd == iStart)
400	{
401	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
402	return 0;
403	}
404	if (iDiff < 0)
405	iEnd = i - 1;
406	else
407	iStart = i + 1;
408	if (iEnd < iStart)
409	{
410	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
411	return 0;
412	}
413	i = iStart + (iEnd - iStart) / 2;
414	}
415
416	/*
417	* Advance the format string and merge flags.
418	*/
419	*ppszFormat += s_aTypes[i].cch - 1;
420	fFlags \|= s_aTypes[i].fFlags;
421
422	/*
423	* Fetch the argument.
424	* It's important that a signed value gets sign-extended up to 64-bit.
425	*/
426	RT_ZERO(u);
427	if (fFlags & RTSTR_F_VALSIGNED)
428	{
429	switch (s_aTypes[i].cb)
430	{
431	case sizeof(int8_t):
432	u.i64 = va_arg(pArgs, /int8_t*/int);
433	fFlags \|= RTSTR_F_8BIT;
434	break;
435	case sizeof(int16_t):
436	u.i64 = va_arg(pArgs, /int16_t*/int);
437	fFlags \|= RTSTR_F_16BIT;
438	break;
439	case sizeof(int32_t):
440	u.i64 = va_arg(*pArgs, int32_t);
441	fFlags \|= RTSTR_F_32BIT;
442	break;
443	case sizeof(int64_t):
444	u.i64 = va_arg(*pArgs, int64_t);
445	fFlags \|= RTSTR_F_64BIT;
446	break;
447	default:
448	AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
449	break;
450	}
451	}
452	else
453	{
454	switch (s_aTypes[i].cb)
455	{
456	case sizeof(uint8_t):
457	u.u8 = va_arg(pArgs, /uint8_t*/unsigned);
458	fFlags \|= RTSTR_F_8BIT;
459	break;
460	case sizeof(uint16_t):
461	u.u16 = va_arg(pArgs, /uint16_t*/unsigned);
462	fFlags \|= RTSTR_F_16BIT;
463	break;
464	case sizeof(uint32_t):
465	u.u32 = va_arg(*pArgs, uint32_t);
466	fFlags \|= RTSTR_F_32BIT;
467	break;
468	case sizeof(uint64_t):
469	u.u64 = va_arg(*pArgs, uint64_t);
470	fFlags \|= RTSTR_F_64BIT;
471	break;
472	case sizeof(RTFAR32):
473	u.fp32 = va_arg(*pArgs, RTFAR32);
474	break;
475	case sizeof(RTFAR64):
476	u.fp64 = va_arg(*pArgs, RTFAR64);
477	break;
478	default:
479	AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
480	break;
481	}
482	}
483
484	#ifndef DEBUG
485	/*
486	* For now don't show the address.
487	*/
488	if (fFlags & RTSTR_F_OBFUSCATE_PTR)
489	{
490	cch = rtStrFormatKernelAddress(szBuf, sizeof(szBuf), u.uR0Ptr, cchWidth, cchPrecision, fFlags);
491	return pfnOutput(pvArgOutput, szBuf, cch);
492	}
493	#endif
494
495	/*
496	* Format the output.
497	*/
498	switch (s_aTypes[i].enmFormat)
499	{
500	case RTSF_INT:
501	{
502	cch = RTStrFormatNumber(szBuf, u.u64, s_aTypes[i].u8Base, cchWidth, cchPrecision, fFlags);
503	break;
504	}
505
506	/* hex which defaults to max width. */
507	case RTSF_INTW:
508	{
509	Assert(s_aTypes[i].u8Base == 16);
510	if (cchWidth < 0)
511	{
512	cchWidth = s_aTypes[i].cb * 2 + (fFlags & RTSTR_F_SPECIAL ? 2 : 0);
513	fFlags \|= RTSTR_F_ZEROPAD;
514	}
515	cch = RTStrFormatNumber(szBuf, u.u64, s_aTypes[i].u8Base, cchWidth, cchPrecision, fFlags);
516	break;
517	}
518
519	case RTSF_BOOL:
520	{
521	static const char s_szTrue[] = "true ";
522	static const char s_szFalse[] = "false";
523	if (u.u64 == 1)
524	return pfnOutput(pvArgOutput, s_szTrue, sizeof(s_szTrue) - 1);
525	if (u.u64 == 0)
526	return pfnOutput(pvArgOutput, s_szFalse, sizeof(s_szFalse) - 1);
527	/* invalid boolean value */
528	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "!%lld!", u.u64);
529	}
530
531	case RTSF_FP16:
532	{
533	fFlags &= ~(RTSTR_F_VALSIGNED \| RTSTR_F_BIT_MASK \| RTSTR_F_WIDTH \| RTSTR_F_PRECISION \| RTSTR_F_THOUSAND_SEP);
534	cch = RTStrFormatNumber(&szBuf[0], u.fp16.sel, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
535	Assert(cch == 4);
536	szBuf[4] = ':';
537	cch = RTStrFormatNumber(&szBuf[5], u.fp16.off, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
538	Assert(cch == 4);
539	cch = 4 + 1 + 4;
540	break;
541	}
542	case RTSF_FP32:
543	{
544	fFlags &= ~(RTSTR_F_VALSIGNED \| RTSTR_F_BIT_MASK \| RTSTR_F_WIDTH \| RTSTR_F_PRECISION \| RTSTR_F_THOUSAND_SEP);
545	cch = RTStrFormatNumber(&szBuf[0], u.fp32.sel, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
546	Assert(cch == 4);
547	szBuf[4] = ':';
548	cch = RTStrFormatNumber(&szBuf[5], u.fp32.off, 16, 8, -1, fFlags \| RTSTR_F_32BIT);
549	Assert(cch == 8);
550	cch = 4 + 1 + 8;
551	break;
552	}
553	case RTSF_FP64:
554	{
555	fFlags &= ~(RTSTR_F_VALSIGNED \| RTSTR_F_BIT_MASK \| RTSTR_F_WIDTH \| RTSTR_F_PRECISION \| RTSTR_F_THOUSAND_SEP);
556	cch = RTStrFormatNumber(&szBuf[0], u.fp64.sel, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
557	Assert(cch == 4);
558	szBuf[4] = ':';
559	cch = RTStrFormatNumber(&szBuf[5], u.fp64.off, 16, 16, -1, fFlags \| RTSTR_F_64BIT);
560	Assert(cch == 16);
561	cch = 4 + 1 + 16;
562	break;
563	}
564
565	case RTSF_IPV4:
566	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
567	"%u.%u.%u.%u",
568	u.Ipv4Addr.au8[0],
569	u.Ipv4Addr.au8[1],
570	u.Ipv4Addr.au8[2],
571	u.Ipv4Addr.au8[3]);
572
573	case RTSF_IPV6:
574	{
575	if (VALID_PTR(u.pIpv6Addr))
576	return rtstrFormatIPv6(pfnOutput, pvArgOutput, u.pIpv6Addr);
577	return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
578	}
579
580	case RTSF_MAC:
581	{
582	if (VALID_PTR(u.pMac))
583	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
584	"%02x:%02x:%02x:%02x:%02x:%02x",
585	u.pMac->au8[0],
586	u.pMac->au8[1],
587	u.pMac->au8[2],
588	u.pMac->au8[3],
589	u.pMac->au8[4],
590	u.pMac->au8[5]);
591	return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
592	}
593
594	case RTSF_NETADDR:
595	{
596	if (VALID_PTR(u.pNetAddr))
597	{
598	switch (u.pNetAddr->enmType)
599	{
600	case RTNETADDRTYPE_IPV4:
601	if (u.pNetAddr->uPort == RTNETADDR_PORT_NA)
602	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
603	"%u.%u.%u.%u",
604	u.pNetAddr->uAddr.IPv4.au8[0],
605	u.pNetAddr->uAddr.IPv4.au8[1],
606	u.pNetAddr->uAddr.IPv4.au8[2],
607	u.pNetAddr->uAddr.IPv4.au8[3]);
608	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
609	"%u.%u.%u.%u:%u",
610	u.pNetAddr->uAddr.IPv4.au8[0],
611	u.pNetAddr->uAddr.IPv4.au8[1],
612	u.pNetAddr->uAddr.IPv4.au8[2],
613	u.pNetAddr->uAddr.IPv4.au8[3],
614	u.pNetAddr->uPort);
615
616	case RTNETADDRTYPE_IPV6:
617	if (u.pNetAddr->uPort == RTNETADDR_PORT_NA)
618	return rtstrFormatIPv6(pfnOutput, pvArgOutput, &u.pNetAddr->uAddr.IPv6);
619
620	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
621	"[%RTnaipv6]:%u",
622	&u.pNetAddr->uAddr.IPv6,
623	u.pNetAddr->uPort);
624
625	case RTNETADDRTYPE_MAC:
626	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
627	"%02x:%02x:%02x:%02x:%02x:%02x",
628	u.pNetAddr->uAddr.Mac.au8[0],
629	u.pNetAddr->uAddr.Mac.au8[1],
630	u.pNetAddr->uAddr.Mac.au8[2],
631	u.pNetAddr->uAddr.Mac.au8[3],
632	u.pNetAddr->uAddr.Mac.au8[4],
633	u.pNetAddr->uAddr.Mac.au8[5]);
634
635	default:
636	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
637	"unsupported-netaddr-type=%u", u.pNetAddr->enmType);
638
639	}
640	}
641	return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
642	}
643
644	case RTSF_UUID:
645	{
646	if (VALID_PTR(u.pUuid))
647	{
648	/* cannot call RTUuidToStr because of GC/R0. */
649	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
650	"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
651	RT_H2LE_U32(u.pUuid->Gen.u32TimeLow),
652	RT_H2LE_U16(u.pUuid->Gen.u16TimeMid),
653	RT_H2LE_U16(u.pUuid->Gen.u16TimeHiAndVersion),
654	u.pUuid->Gen.u8ClockSeqHiAndReserved,
655	u.pUuid->Gen.u8ClockSeqLow,
656	u.pUuid->Gen.au8Node[0],
657	u.pUuid->Gen.au8Node[1],
658	u.pUuid->Gen.au8Node[2],
659	u.pUuid->Gen.au8Node[3],
660	u.pUuid->Gen.au8Node[4],
661	u.pUuid->Gen.au8Node[5]);
662	}
663	return pfnOutput(pvArgOutput, s_szNull, sizeof(s_szNull) - 1);
664	}
665
666	case RTSF_ERRINFO:
667	case RTSF_ERRINFO_MSG_ONLY:
668	{
669	if (VALID_PTR(u.pErrInfo) && RTErrInfoIsSet(u.pErrInfo))
670	{
671	cch = 0;
672	if (s_aTypes[i].enmFormat == RTSF_ERRINFO)
673	{
674	#ifdef IN_RING3 /* we don't want this anywhere else yet. */
675	cch += RTErrFormatMsgShort(u.pErrInfo->rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
676	#else
677	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%d", u.pErrInfo->rc);
678	#endif
679	}
680
681	if (u.pErrInfo->cbMsg > 0)
682	{
683	if (fFlags & RTSTR_F_SPECIAL)
684	cch = pfnOutput(pvArgOutput, RT_STR_TUPLE(" - "));
685	else
686	cch = pfnOutput(pvArgOutput, RT_STR_TUPLE(": "));
687	cch += pfnOutput(pvArgOutput, u.pErrInfo->pszMsg, u.pErrInfo->cbMsg);
688	}
689	return cch;
690	}
691	return 0;
692	}
693
694	default:
695	AssertMsgFailed(("Internal error %d\n", s_aTypes[i].enmFormat));
696	return 0;
697	}
698
699	/*
700	* Finally, output the formatted string and return.
701	*/
702	return pfnOutput(pvArgOutput, szBuf, cch);
703	}
704
705
706	/* Group 3 */
707
708	/*
709	* Base name printing, big endian UTF-16.
710	*/
711	case 'b':
712	{
713	switch ((ppszFormat)++)
714	{
715	case 'n':
716	{
717	const char *pszLastSep;
718	const char psz = pszLastSep = va_arg(pArgs, const char *);
719	if (!VALID_PTR(psz))
720	return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
721
722	while ((ch = *psz) != '\0')
723	{
724	if (RTPATH_IS_SEP(ch))
725	{
726	do
727	psz++;
728	while ((ch = *psz) != '\0' && RTPATH_IS_SEP(ch));
729	if (!ch)
730	break;
731	pszLastSep = psz;
732	}
733	psz++;
734	}
735
736	return pfnOutput(pvArgOutput, pszLastSep, psz - pszLastSep);
737	}
738
739	/* %lRbs */
740	case 's':
741	if (chArgSize == 'l')
742	{
743	/* utf-16BE -> utf-8 */
744	int cchStr;
745	PCRTUTF16 pwszStr = va_arg(*pArgs, PRTUTF16);
746
747	if (RT_VALID_PTR(pwszStr))
748	{
749	cchStr = 0;
750	while (cchStr < cchPrecision && pwszStr[cchStr] != '\0')
751	cchStr++;
752	}
753	else
754	{
755	static RTUTF16 s_wszBigNull[] =
756	{
757	RT_H2BE_U16_C((uint16_t)'<'), RT_H2BE_U16_C((uint16_t)'N'), RT_H2BE_U16_C((uint16_t)'U'),
758	RT_H2BE_U16_C((uint16_t)'L'), RT_H2BE_U16_C((uint16_t)'L'), RT_H2BE_U16_C((uint16_t)'>'), '\0'
759	};
760	pwszStr = s_wszBigNull;
761	cchStr = RT_ELEMENTS(s_wszBigNull) - 1;
762	}
763
764	cch = 0;
765	if (!(fFlags & RTSTR_F_LEFT))
766	while (--cchWidth >= cchStr)
767	cch += pfnOutput(pvArgOutput, " ", 1);
768	cchWidth -= cchStr;
769	while (cchStr-- > 0)
770	{
771	/** @todo \#ifndef IN_RC*/
772	#ifdef IN_RING3
773	RTUNICP Cp = 0;
774	RTUtf16BigGetCpEx(&pwszStr, &Cp);
775	char *pszEnd = RTStrPutCp(szBuf, Cp);
776	*pszEnd = '\0';
777	cch += pfnOutput(pvArgOutput, szBuf, pszEnd - szBuf);
778	#else
779	szBuf[0] = (char)(*pwszStr++ >> 8);
780	cch += pfnOutput(pvArgOutput, szBuf, 1);
781	#endif
782	}
783	while (--cchWidth >= 0)
784	cch += pfnOutput(pvArgOutput, " ", 1);
785	return cch;
786	}
787	RT_FALL_THRU();
788
789	default:
790	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
791	break;
792	}
793	break;
794	}
795
796
797	/*
798	* Pretty function / method name printing.
799	*/
800	case 'f':
801	{
802	switch ((ppszFormat)++)
803	{
804	/*
805	* Pretty function / method name printing.
806	* This isn't 100% right (see classic signal prototype) and it assumes
807	* standardized names, but it'll do for today.
808	*/
809	case 'n':
810	{
811	const char *pszStart;
812	const char psz = pszStart = va_arg(pArgs, const char *);
813	int cAngle = 0;
814
815	if (!VALID_PTR(psz))
816	return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
817
818	while ((ch = *psz) != '\0' && ch != '(')
819	{
820	if (RT_C_IS_BLANK(ch))
821	{
822	psz++;
823	while ((ch = *psz) != '\0' && (RT_C_IS_BLANK(ch) \|\| ch == '('))
824	psz++;
825	if (ch && cAngle == 0)
826	pszStart = psz;
827	}
828	else if (ch == '(')
829	break;
830	else if (ch == '<')
831	{
832	cAngle++;
833	psz++;
834	}
835	else if (ch == '>')
836	{
837	cAngle--;
838	psz++;
839	}
840	else
841	psz++;
842	}
843
844	return pfnOutput(pvArgOutput, pszStart, psz - pszStart);
845	}
846
847	default:
848	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
849	break;
850	}
851	break;
852	}
853
854
855	/*
856	* hex dumping, COM/XPCOM, human readable sizes.
857	*/
858	case 'h':
859	{
860	ch = (ppszFormat)++;
861	switch (ch)
862	{
863	/*
864	* Hex stuff.
865	*/
866	case 'x':
867	case 'X':
868	{
869	uint8_t pu8 = va_arg(pArgs, uint8_t *);
870	uint64_t uMemAddr;
871	int cchMemAddrWidth;
872
873	if (cchPrecision < 0)
874	cchPrecision = 16;
875
876	if (ch == 'x')
877	{
878	uMemAddr = (uintptr_t)pu8;
879	cchMemAddrWidth = sizeof(pu8) * 2;
880	}
881	else
882	{
883	uMemAddr = va_arg(*pArgs, uint64_t);
884	cchMemAddrWidth = uMemAddr > UINT32_MAX \|\| uMemAddr + cchPrecision > UINT32_MAX ? 16 : 8;
885	}
886
887	if (pu8)
888	{
889	switch ((ppszFormat)++)
890	{
891	/*
892	* Regular hex dump.
893	*/
894	case 'd':
895	{
896	int off = 0;
897	cch = 0;
898
899	if (cchWidth <= 0)
900	cchWidth = 16;
901
902	while (off < cchPrecision)
903	{
904	int i;
905	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s%0*llx/%04x:",
906	off ? "\n" : "", cchMemAddrWidth, uMemAddr + off, off);
907	for (i = 0; i < cchWidth && off + i < cchPrecision ; i++)
908	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
909	off + i < cchPrecision ? !(i & 7) && i ? "-%02x" : " %02x" : " ",
910	pu8[i]);
911	while (i++ < cchWidth)
912	cch += pfnOutput(pvArgOutput, " ", 3);
913
914	cch += pfnOutput(pvArgOutput, " ", 1);
915
916	for (i = 0; i < cchWidth && off + i < cchPrecision; i++)
917	{
918	uint8_t u8 = pu8[i];
919	cch += pfnOutput(pvArgOutput, u8 < 127 && u8 >= 32 ? (const char *)&u8 : ".", 1);
920	}
921
922	/* next */
923	pu8 += cchWidth;
924	off += cchWidth;
925	}
926	return cch;
927	}
928
929	/*
930	* Regular hex dump with dittoing.
931	*/
932	case 'D':
933	{
934	int offEndDupCheck;
935	int cDuplicates = 0;
936	int off = 0;
937	cch = 0;
938
939	if (cchWidth <= 0)
940	cchWidth = 16;
941	offEndDupCheck = cchPrecision - cchWidth;
942
943	while (off < cchPrecision)
944	{
945	int i;
946	if ( off >= offEndDupCheck
947	\|\| off <= 0
948	\|\| memcmp(pu8, pu8 - cchWidth, cchWidth) != 0
949	\|\| ( cDuplicates == 0
950	&& ( off + cchWidth >= offEndDupCheck
951	\|\| memcmp(pu8 + cchWidth, pu8, cchWidth) != 0)) )
952	{
953	if (cDuplicates > 0)
954	{
955	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "\n%.s *** <ditto x %u>",
956	cchMemAddrWidth, "****************", cDuplicates);
957	cDuplicates = 0;
958	}
959
960	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s%0*llx/%04x:",
961	off ? "\n" : "", cchMemAddrWidth, uMemAddr + off, off);
962	for (i = 0; i < cchWidth && off + i < cchPrecision ; i++)
963	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
964	off + i < cchPrecision ? !(i & 7) && i
965	? "-%02x" : " %02x" : " ",
966	pu8[i]);
967	while (i++ < cchWidth)
968	cch += pfnOutput(pvArgOutput, " ", 3);
969
970	cch += pfnOutput(pvArgOutput, " ", 1);
971
972	for (i = 0; i < cchWidth && off + i < cchPrecision; i++)
973	{
974	uint8_t u8 = pu8[i];
975	cch += pfnOutput(pvArgOutput, u8 < 127 && u8 >= 32 ? (const char *)&u8 : ".", 1);
976	}
977	}
978	else
979	cDuplicates++;
980
981	/* next */
982	pu8 += cchWidth;
983	off += cchWidth;
984	}
985	return cch;
986	}
987
988	/*
989	* Hex string.
990	*/
991	case 's':
992	{
993	if (cchPrecision-- > 0)
994	{
995	if (ch == 'x')
996	cch = RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%02x", *pu8++);
997	else
998	cch = RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%0*llx: %02x",
999	cchMemAddrWidth, uMemAddr, *pu8++);
1000	for (; cchPrecision > 0; cchPrecision--, pu8++)
1001	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, " %02x", *pu8);
1002	return cch;
1003	}
1004	break;
1005	}
1006
1007	default:
1008	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1009	break;
1010	}
1011	}
1012	else
1013	return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
1014	break;
1015	}
1016
1017
1018	#ifdef IN_RING3
1019	/*
1020	* XPCOM / COM status code: %Rhrc, %Rhrf, %Rhra
1021	* ASSUMES: If Windows Then COM else XPCOM.
1022	*/
1023	case 'r':
1024	{
1025	uint32_t hrc = va_arg(*pArgs, uint32_t);
1026	PCRTCOMERRMSG pMsg = RTErrCOMGet(hrc);
1027	switch ((ppszFormat)++)
1028	{
1029	case 'c':
1030	return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
1031	case 'f':
1032	# if !defined(RT_OS_WINDOWS) \|\| (!defined(RT_IN_STATIC) && !defined(IPRT_ERRMSG_DEFINES_ONLY))
1033	return pfnOutput(pvArgOutput, pMsg->pszMsgFull, strlen(pMsg->pszMsgFull));
1034	# else
1035	AssertFailed();
1036	return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
1037	# endif
1038	case 'a':
1039	# if !defined(RT_OS_WINDOWS) \|\| (!defined(RT_IN_STATIC) && !defined(IPRT_ERRMSG_DEFINES_ONLY))
1040	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X) - %s", pMsg->pszDefine, hrc, pMsg->pszMsgFull);
1041	# else
1042	AssertFailed();
1043	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X)", pMsg->pszDefine, hrc);
1044	# endif
1045	default:
1046	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1047	return 0;
1048	}
1049	break;
1050	}
1051	#endif /* IN_RING3 */
1052
1053	/*
1054	* Human readable sizes.
1055	*/
1056	case 'c':
1057	case 'u':
1058	{
1059	unsigned i;
1060	ssize_t cchBuf;
1061	uint64_t uValue;
1062	uint64_t uFraction = 0;
1063	const char *pszPrefix = NULL;
1064	char ch2 = (ppszFormat)++;
1065	AssertMsgReturn(ch2 == 'b' \|\| ch2 == 'B' \|\| ch2 == 'i', ("invalid type '%.10s'!\n", pszFormatOrg), 0);
1066	uValue = va_arg(*pArgs, uint64_t);
1067
1068	if (!(fFlags & RTSTR_F_PRECISION))
1069	cchPrecision = 1; /** @todo default to flexible decimal point. */
1070	else if (cchPrecision > 3)
1071	cchPrecision = 3;
1072	else if (cchPrecision < 0)
1073	cchPrecision = 0;
1074
1075	if (ch2 == 'b' \|\| ch2 == 'B')
1076	{
1077	static const struct
1078	{
1079	const char *pszPrefix;
1080	uint8_t cShift;
1081	uint64_t cbMin;
1082	uint64_t cbMinZeroPrecision;
1083	} s_aUnits[] =
1084	{
1085	{ "Ei", 60, _1E, _1E*2 },
1086	{ "Pi", 50, _1P, _1P*2 },
1087	{ "Ti", 40, _1T, _1T*2 },
1088	{ "Gi", 30, _1G, _1G64*2 },
1089	{ "Mi", 20, _1M, _1M*2 },
1090	{ "Ki", 10, _1K, _1K*2 },
1091	};
1092	for (i = 0; i < RT_ELEMENTS(s_aUnits); i++)
1093	if ( uValue >= s_aUnits[i].cbMin
1094	&& (cchPrecision > 0 \|\| uValue >= s_aUnits[i].cbMinZeroPrecision))
1095	{
1096	if (cchPrecision != 0)
1097	{
1098	uFraction = uValue & (RT_BIT_64(s_aUnits[i].cShift) - 1);
1099	uFraction *= cchPrecision == 1 ? 10 : cchPrecision == 2 ? 100 : 1000;
1100	uFraction >>= s_aUnits[i].cShift;
1101	}
1102	uValue >>= s_aUnits[i].cShift;
1103	pszPrefix = s_aUnits[i].pszPrefix;
1104	break;
1105	}
1106	}
1107	else
1108	{
1109	static const struct
1110	{
1111	const char *pszPrefix;
1112	uint64_t cbFactor;
1113	uint64_t cbMinZeroPrecision;
1114	} s_aUnits[] =
1115	{
1116	{ "E", UINT64_C(1000000000000000000), UINT64_C(1010000000000000000), },
1117	{ "P", UINT64_C(1000000000000000), UINT64_C(1010000000000000), },
1118	{ "T", UINT64_C(1000000000000), UINT64_C(1010000000000), },
1119	{ "G", UINT64_C(1000000000), UINT64_C(1010000000), },
1120	{ "M", UINT64_C(1000000), UINT64_C(1010000), },
1121	{ "k", UINT64_C(1000), UINT64_C(1010), },
1122	};
1123	for (i = 0; i < RT_ELEMENTS(s_aUnits); i++)
1124	if ( uValue >= s_aUnits[i].cbFactor
1125	&& (cchPrecision > 0 \|\| uValue >= s_aUnits[i].cbMinZeroPrecision))
1126	{
1127	if (cchPrecision == 0)
1128	uValue /= s_aUnits[i].cbFactor;
1129	else
1130	{
1131	uFraction = uValue % s_aUnits[i].cbFactor;
1132	uValue = uValue / s_aUnits[i].cbFactor;
1133	uFraction *= cchPrecision == 1 ? 10 : cchPrecision == 2 ? 100 : 1000;
1134	uFraction += s_aUnits[i].cbFactor >> 1;
1135	uFraction /= s_aUnits[i].cbFactor;
1136	}
1137	pszPrefix = s_aUnits[i].pszPrefix;
1138	break;
1139	}
1140	}
1141
1142	cchBuf = RTStrFormatU64(szBuf, sizeof(szBuf), uValue, 10, 0, 0, 0);
1143	if (pszPrefix)
1144	{
1145	if (cchPrecision)
1146	{
1147	szBuf[cchBuf++] = '.';
1148	cchBuf += RTStrFormatU64(&szBuf[cchBuf], sizeof(szBuf) - cchBuf, uFraction, 10, cchPrecision, 0,
1149	RTSTR_F_ZEROPAD \| RTSTR_F_WIDTH);
1150	}
1151	if (fFlags & RTSTR_F_BLANK)
1152	szBuf[cchBuf++] = ' ';
1153	szBuf[cchBuf++] = *pszPrefix++;
1154	if (*pszPrefix && ch2 != 'B')
1155	szBuf[cchBuf++] = *pszPrefix;
1156	}
1157	else if (fFlags & RTSTR_F_BLANK)
1158	szBuf[cchBuf++] = ' ';
1159	if (ch == 'c')
1160	szBuf[cchBuf++] = 'B';
1161	szBuf[cchBuf] = '\0';
1162
1163	cch = 0;
1164	if ((fFlags & RTSTR_F_WIDTH) && !(fFlags & RTSTR_F_LEFT))
1165	while (cchBuf < cchWidth)
1166	{
1167	cch += pfnOutput(pvArgOutput, fFlags & RTSTR_F_ZEROPAD ? "0" : " ", 1);
1168	cchWidth--;
1169	}
1170	cch += pfnOutput(pvArgOutput, szBuf, cchBuf);
1171	return cch;
1172	}
1173
1174	default:
1175	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1176	return 0;
1177
1178	}
1179	break;
1180	}
1181
1182	/*
1183	* iprt status code: %Rrc, %Rrs, %Rrf, %Rra.
1184	*/
1185	case 'r':
1186	{
1187	int rc = va_arg(*pArgs, int);
1188	#ifdef IN_RING3 /* we don't want this anywhere else yet. */
1189	switch ((ppszFormat)++)
1190	{
1191	case 'c':
1192	return RTErrFormatDefine(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1193	case 's':
1194	return RTErrFormatMsgShort(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1195	case 'f':
1196	return RTErrFormatMsgFull(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1197	case 'a':
1198	return RTErrFormatMsgAll(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1199	default:
1200	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1201	return 0;
1202	}
1203	#else /* !IN_RING3 */
1204	switch ((ppszFormat)++)
1205	{
1206	case 'c':
1207	case 's':
1208	case 'f':
1209	case 'a':
1210	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%d", rc);
1211	default:
1212	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1213	return 0;
1214	}
1215	#endif /* !IN_RING3 */
1216	break;
1217	}
1218
1219	#if defined(IN_RING3)
1220	/*
1221	* Windows status code: %Rwc, %Rwf, %Rwa
1222	*/
1223	case 'w':
1224	{
1225	long rc = va_arg(*pArgs, long);
1226	# if defined(RT_OS_WINDOWS)
1227	PCRTWINERRMSG pMsg = RTErrWinGet(rc);
1228	# endif
1229	switch ((ppszFormat)++)
1230	{
1231	# if defined(RT_OS_WINDOWS)
1232	case 'c':
1233	return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
1234	case 'f':
1235	# if !defined(RT_IN_STATIC) && !defined(IPRT_ERRMSG_DEFINES_ONLY)
1236	return pfnOutput(pvArgOutput, pMsg->pszMsgFull, strlen(pMsg->pszMsgFull));
1237	# else
1238	AssertFailed();
1239	return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
1240	# endif
1241	case 'a':
1242	# if !defined(RT_IN_STATIC) && !defined(IPRT_ERRMSG_DEFINES_ONLY)
1243	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X) - %s", pMsg->pszDefine, rc, pMsg->pszMsgFull);
1244	# else
1245	AssertFailed();
1246	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X)", pMsg->pszDefine, rc);
1247	# endif
1248	# else /* !RT_OS_WINDOWS */
1249	case 'c':
1250	case 'f':
1251	case 'a':
1252	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "0x%08X", rc);
1253	# endif /* !RT_OS_WINDOWS */
1254	default:
1255	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1256	return 0;
1257	}
1258	break;
1259	}
1260	#endif /* IN_RING3 */
1261
1262	/*
1263	* Group 4, structure dumpers.
1264	*/
1265	case 'D':
1266	{
1267	/*
1268	* Interpret the type.
1269	*/
1270	typedef enum
1271	{
1272	RTST_TIMESPEC
1273	} RTST;
1274	/** Set if it's a pointer */
1275	#define RTST_FLAGS_POINTER RT_BIT(0)
1276	static const struct
1277	{
1278	uint8_t cch; /*< the length of the string. /
1279	char sz[16-2]; /*< the part following 'R'. /
1280	uint8_t cb; /*< the size of the argument. /
1281	uint8_t fFlags; /*< RTST_FLAGS_ */
1282	RTST enmType; /*< The structure type. /
1283	}
1284	/** Sorted array of types, looked up using binary search! */
1285	s_aTypes[] =
1286	{
1287	#define STRMEM(str) sizeof(str) - 1, str
1288	{ STRMEM("Dtimespec"), sizeof(PCRTTIMESPEC), RTST_FLAGS_POINTER, RTST_TIMESPEC},
1289	#undef STRMEM
1290	};
1291	const char pszType = ppszFormat - 1;
1292	int iStart = 0;
1293	int iEnd = RT_ELEMENTS(s_aTypes) - 1;
1294	int i = RT_ELEMENTS(s_aTypes) / 2;
1295
1296	union
1297	{
1298	const void *pv;
1299	uint64_t u64;
1300	PCRTTIMESPEC pTimeSpec;
1301	} u;
1302
1303	AssertMsg(!chArgSize, ("Not argument size '%c' for RT types! '%.10s'\n", chArgSize, pszFormatOrg));
1304
1305	/*
1306	* Lookup the type - binary search.
1307	*/
1308	for (;;)
1309	{
1310	int iDiff = strncmp(pszType, s_aTypes[i].sz, s_aTypes[i].cch);
1311	if (!iDiff)
1312	break;
1313	if (iEnd == iStart)
1314	{
1315	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
1316	return 0;
1317	}
1318	if (iDiff < 0)
1319	iEnd = i - 1;
1320	else
1321	iStart = i + 1;
1322	if (iEnd < iStart)
1323	{
1324	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
1325	return 0;
1326	}
1327	i = iStart + (iEnd - iStart) / 2;
1328	}
1329	*ppszFormat += s_aTypes[i].cch - 1;
1330
1331	/*
1332	* Fetch the argument.
1333	*/
1334	u.u64 = 0;
1335	switch (s_aTypes[i].cb)
1336	{
1337	case sizeof(const void *):
1338	u.pv = va_arg(pArgs, const void );
1339	break;
1340	default:
1341	AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
1342	break;
1343	}
1344
1345	/*
1346	* If it's a pointer, we'll check if it's valid before going on.
1347	*/
1348	if ((s_aTypes[i].fFlags & RTST_FLAGS_POINTER) && !VALID_PTR(u.pv))
1349	return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
1350
1351	/*
1352	* Format the output.
1353	*/
1354	switch (s_aTypes[i].enmType)
1355	{
1356	case RTST_TIMESPEC:
1357	return RTStrFormat(pfnOutput, pvArgOutput, NULL, NULL, "%'lld ns", RTTimeSpecGetNano(u.pTimeSpec));
1358
1359	default:
1360	AssertMsgFailed(("Invalid/unhandled enmType=%d\n", s_aTypes[i].enmType));
1361	break;
1362	}
1363	break;
1364	}
1365
1366	#ifdef IN_RING3
1367
1368	/*
1369	* Group 5, XML / HTML, JSON and URI escapers.
1370	*/
1371	case 'M':
1372	{
1373	char chWhat = (*ppszFormat)[0];
1374	if (chWhat == 'a' \|\| chWhat == 'e')
1375	{
1376	/* XML attributes and element values. */
1377	bool fAttr = chWhat == 'a';
1378	char chType = (*ppszFormat)[1];
1379	*ppszFormat += 2;
1380	switch (chType)
1381	{
1382	case 's':
1383	{
1384	static const char s_szElemEscape[] = "<>&\"'";
1385	static const char s_szAttrEscape[] = "<>&\"\n\r"; /* more? */
1386	const char * const pszEscape = fAttr ? s_szAttrEscape : s_szElemEscape;
1387	size_t const cchEscape = (fAttr ? RT_ELEMENTS(s_szAttrEscape) : RT_ELEMENTS(s_szElemEscape)) - 1;
1388	size_t cchOutput = 0;
1389	const char pszStr = va_arg(pArgs, char *);
1390	ssize_t cchStr;
1391	ssize_t offCur;
1392	ssize_t offLast;
1393
1394	if (!VALID_PTR(pszStr))
1395	pszStr = "<NULL>";
1396	cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
1397
1398	if (fAttr)
1399	cchOutput += pfnOutput(pvArgOutput, "\"", 1);
1400	if (!(fFlags & RTSTR_F_LEFT))
1401	while (--cchWidth >= cchStr)
1402	cchOutput += pfnOutput(pvArgOutput, " ", 1);
1403
1404	offLast = offCur = 0;
1405	while (offCur < cchStr)
1406	{
1407	if (memchr(pszEscape, pszStr[offCur], cchEscape))
1408	{
1409	if (offLast < offCur)
1410	cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1411	switch (pszStr[offCur])
1412	{
1413	case '<': cchOutput += pfnOutput(pvArgOutput, "<", 4); break;
1414	case '>': cchOutput += pfnOutput(pvArgOutput, ">", 4); break;
1415	case '&': cchOutput += pfnOutput(pvArgOutput, "&", 5); break;
1416	case '\'': cchOutput += pfnOutput(pvArgOutput, "'", 6); break;
1417	case '"': cchOutput += pfnOutput(pvArgOutput, """, 6); break;
1418	case '\n': cchOutput += pfnOutput(pvArgOutput, " ", 5); break;
1419	case '\r': cchOutput += pfnOutput(pvArgOutput, " ", 5); break;
1420	default:
1421	AssertFailed();
1422	}
1423	offLast = offCur + 1;
1424	}
1425	offCur++;
1426	}
1427	if (offLast < offCur)
1428	cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1429
1430	while (--cchWidth >= cchStr)
1431	cchOutput += pfnOutput(pvArgOutput, " ", 1);
1432	if (fAttr)
1433	cchOutput += pfnOutput(pvArgOutput, "\"", 1);
1434	return cchOutput;
1435	}
1436
1437	default:
1438	AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1439	}
1440	}
1441	else if (chWhat == 'j')
1442	{
1443	/* JSON string escaping. */
1444	char const chType = (*ppszFormat)[1];
1445	*ppszFormat += 2;
1446	switch (chType)
1447	{
1448	case 's':
1449	{
1450	const char pszStr = va_arg(pArgs, char *);
1451	size_t cchOutput;
1452	ssize_t cchStr;
1453	ssize_t offCur;
1454	ssize_t offLast;
1455
1456	if (!VALID_PTR(pszStr))
1457	pszStr = "<NULL>";
1458	cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
1459
1460	cchOutput = pfnOutput(pvArgOutput, "\"", 1);
1461	if (!(fFlags & RTSTR_F_LEFT))
1462	while (--cchWidth >= cchStr)
1463	cchOutput += pfnOutput(pvArgOutput, " ", 1);
1464
1465	offLast = offCur = 0;
1466	while (offCur < cchStr)
1467	{
1468	unsigned int const uch = pszStr[offCur];
1469	if ( uch >= 0x5d
1470	\|\| (uch >= 0x20 && uch != 0x22 && uch != 0x5c))
1471	offCur++;
1472	else
1473	{
1474	if (offLast < offCur)
1475	cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1476	switch ((char)uch)
1477	{
1478	case '"': cchOutput += pfnOutput(pvArgOutput, "\\\"", 2); break;
1479	case '\\': cchOutput += pfnOutput(pvArgOutput, "\\\\", 2); break;
1480	case '/': cchOutput += pfnOutput(pvArgOutput, "\\/", 2); break;
1481	case '\b': cchOutput += pfnOutput(pvArgOutput, "\\b", 2); break;
1482	case '\f': cchOutput += pfnOutput(pvArgOutput, "\\f", 2); break;
1483	case '\n': cchOutput += pfnOutput(pvArgOutput, "\\n", 2); break;
1484	case '\t': cchOutput += pfnOutput(pvArgOutput, "\\t", 2); break;
1485	default:
1486	{
1487	RTUNICP uc = 0xfffd; /* replacement character */
1488	const char *pszCur = &pszStr[offCur];
1489	int rc = RTStrGetCpEx(&pszCur, &uc);
1490	if (RT_SUCCESS(rc))
1491	offCur += pszCur - &pszStr[offCur] - 1;
1492	if (uc >= 0xfffe)
1493	uc = 0xfffd; /* replacement character */
1494	szBuf[0] = '\\';
1495	szBuf[1] = 'u';
1496	szBuf[2] = g_szHexDigits[(uc >> 12) & 0xf];
1497	szBuf[3] = g_szHexDigits[(uc >> 8) & 0xf];
1498	szBuf[4] = g_szHexDigits[(uc >> 4) & 0xf];
1499	szBuf[5] = g_szHexDigits[ uc & 0xf];
1500	szBuf[6] = '\0';
1501	cchOutput += pfnOutput(pvArgOutput, szBuf, 6);
1502	break;
1503	}
1504	}
1505	offLast = ++offCur;
1506	}
1507	}
1508	if (offLast < offCur)
1509	cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1510
1511	while (--cchWidth >= cchStr)
1512	cchOutput += pfnOutput(pvArgOutput, " ", 1);
1513	cchOutput += pfnOutput(pvArgOutput, "\"", 1);
1514	return cchOutput;
1515	}
1516
1517	default:
1518	AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1519	}
1520	}
1521	else if (chWhat == 'p')
1522	{
1523	/* Percent encoded string (RTC-3986). */
1524	char const chVariant = (*ppszFormat)[1];
1525	char const chAddSafe = chVariant == 'p' ? '/'
1526	: chVariant == 'q' ? '+' /* '+' in queries is problematic, so no escape. */
1527	: '~' /* whatever */;
1528	size_t cchOutput = 0;
1529	const char pszStr = va_arg(pArgs, char *);
1530	ssize_t cchStr;
1531	ssize_t offCur;
1532	ssize_t offLast;
1533
1534	*ppszFormat += 2;
1535	AssertMsgBreak(chVariant == 'a' \|\| chVariant == 'p' \|\| chVariant == 'q' \|\| chVariant == 'f',
1536	("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1537
1538	if (!VALID_PTR(pszStr))
1539	pszStr = "<NULL>";
1540	cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
1541
1542	if (!(fFlags & RTSTR_F_LEFT))
1543	while (--cchWidth >= cchStr)
1544	cchOutput += pfnOutput(pvArgOutput, "%20", 3);
1545
1546	offLast = offCur = 0;
1547	while (offCur < cchStr)
1548	{
1549	ch = pszStr[offCur];
1550	if ( RT_C_IS_ALPHA(ch)
1551	\|\| RT_C_IS_DIGIT(ch)
1552	\|\| ch == '-'
1553	\|\| ch == '.'
1554	\|\| ch == '_'
1555	\|\| ch == '~'
1556	\|\| ch == chAddSafe)
1557	offCur++;
1558	else
1559	{
1560	if (offLast < offCur)
1561	cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1562	if (ch != ' ' \|\| chVariant != 'f')
1563	{
1564	szBuf[0] = '%';
1565	szBuf[1] = g_szHexDigitsUpper[((uint8_t)ch >> 4) & 0xf];
1566	szBuf[2] = g_szHexDigitsUpper[(uint8_t)ch & 0xf];
1567	szBuf[3] = '\0';
1568	cchOutput += pfnOutput(pvArgOutput, szBuf, 3);
1569	}
1570	else
1571	cchOutput += pfnOutput(pvArgOutput, "+", 1);
1572	offLast = ++offCur;
1573	}
1574	}
1575	if (offLast < offCur)
1576	cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1577
1578	while (--cchWidth >= cchStr)
1579	cchOutput += pfnOutput(pvArgOutput, "%20", 3);
1580	}
1581	else
1582	AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1583	break;
1584	}
1585
1586	#endif /* IN_RING3 */
1587
1588	/*
1589	* Groups 6 - CPU Architecture Register Formatters.
1590	* "%RAarch[reg]"
1591	*/
1592	case 'A':
1593	{
1594	char const * const pszArch = *ppszFormat;
1595	const char *pszReg = pszArch;
1596	size_t cchOutput = 0;
1597	int cPrinted = 0;
1598	size_t cchReg;
1599
1600	/* Parse out the */
1601	while ((ch = *pszReg++) && ch != '[')
1602	{ /* nothing */ }
1603	AssertMsgBreak(ch == '[', ("Malformed IPRT architecture register format type '%.10s'!\n", pszFormatOrg));
1604
1605	cchReg = 0;
1606	while ((ch = pszReg[cchReg]) && ch != ']')
1607	cchReg++;
1608	AssertMsgBreak(ch == ']', ("Malformed IPRT architecture register format type '%.10s'!\n", pszFormatOrg));
1609
1610	*ppszFormat = &pszReg[cchReg + 1];
1611
1612
1613	#define REG_EQUALS(a_szReg) (sizeof(a_szReg) - 1 == cchReg && !strncmp(a_szReg, pszReg, sizeof(a_szReg) - 1))
1614	#define REG_OUT_BIT(a_uVal, a_fBitMask, a_szName) \
1615	do { \
1616	if ((a_uVal) & (a_fBitMask)) \
1617	{ \
1618	if (!cPrinted++) \
1619	cchOutput += pfnOutput(pvArgOutput, "{" a_szName, sizeof(a_szName)); \
1620	else \
1621	cchOutput += pfnOutput(pvArgOutput, "," a_szName, sizeof(a_szName)); \
1622	(a_uVal) &= ~(a_fBitMask); \
1623	} \
1624	} while (0)
1625	#define REG_OUT_CLOSE(a_uVal) \
1626	do { \
1627	if ((a_uVal)) \
1628	{ \
1629	cchOutput += pfnOutput(pvArgOutput, !cPrinted ? "{unkn=" : ",unkn=", 6); \
1630	cch = RTStrFormatNumber(&szBuf[0], (a_uVal), 16, 1, -1, fFlags); \
1631	cchOutput += pfnOutput(pvArgOutput, szBuf, cch); \
1632	cPrinted++; \
1633	} \
1634	if (cPrinted) \
1635	cchOutput += pfnOutput(pvArgOutput, "}", 1); \
1636	} while (0)
1637
1638
1639	if (0)
1640	{ /* dummy */ }
1641	#ifdef STRFORMAT_WITH_X86
1642	/*
1643	* X86 & AMD64.
1644	*/
1645	else if ( pszReg - pszArch == 3 + 1
1646	&& pszArch[0] == 'x'
1647	&& pszArch[1] == '8'
1648	&& pszArch[2] == '6')
1649	{
1650	if (REG_EQUALS("cr0"))
1651	{
1652	uint64_t cr0 = va_arg(*pArgs, uint64_t);
1653	fFlags \|= RTSTR_F_64BIT;
1654	cch = RTStrFormatNumber(&szBuf[0], cr0, 16, 8, -1, fFlags \| RTSTR_F_ZEROPAD);
1655	cchOutput += pfnOutput(pvArgOutput, szBuf, cch);
1656	REG_OUT_BIT(cr0, X86_CR0_PE, "PE");
1657	REG_OUT_BIT(cr0, X86_CR0_MP, "MP");
1658	REG_OUT_BIT(cr0, X86_CR0_EM, "EM");
1659	REG_OUT_BIT(cr0, X86_CR0_TS, "DE");
1660	REG_OUT_BIT(cr0, X86_CR0_ET, "ET");
1661	REG_OUT_BIT(cr0, X86_CR0_NE, "NE");
1662	REG_OUT_BIT(cr0, X86_CR0_WP, "WP");
1663	REG_OUT_BIT(cr0, X86_CR0_AM, "AM");
1664	REG_OUT_BIT(cr0, X86_CR0_NW, "NW");
1665	REG_OUT_BIT(cr0, X86_CR0_CD, "CD");
1666	REG_OUT_BIT(cr0, X86_CR0_PG, "PG");
1667	REG_OUT_CLOSE(cr0);
1668	}
1669	else if (REG_EQUALS("cr4"))
1670	{
1671	uint64_t cr4 = va_arg(*pArgs, uint64_t);
1672	fFlags \|= RTSTR_F_64BIT;
1673	cch = RTStrFormatNumber(&szBuf[0], cr4, 16, 8, -1, fFlags \| RTSTR_F_ZEROPAD);
1674	cchOutput += pfnOutput(pvArgOutput, szBuf, cch);
1675	REG_OUT_BIT(cr4, X86_CR4_VME, "VME");
1676	REG_OUT_BIT(cr4, X86_CR4_PVI, "PVI");
1677	REG_OUT_BIT(cr4, X86_CR4_TSD, "TSD");
1678	REG_OUT_BIT(cr4, X86_CR4_DE, "DE");
1679	REG_OUT_BIT(cr4, X86_CR4_PSE, "PSE");
1680	REG_OUT_BIT(cr4, X86_CR4_PAE, "PAE");
1681	REG_OUT_BIT(cr4, X86_CR4_MCE, "MCE");
1682	REG_OUT_BIT(cr4, X86_CR4_PGE, "PGE");
1683	REG_OUT_BIT(cr4, X86_CR4_PCE, "PCE");
1684	REG_OUT_BIT(cr4, X86_CR4_OSFXSR, "OSFXSR");
1685	REG_OUT_BIT(cr4, X86_CR4_OSXMMEEXCPT, "OSXMMEEXCPT");
1686	REG_OUT_BIT(cr4, X86_CR4_VMXE, "VMXE");
1687	REG_OUT_BIT(cr4, X86_CR4_SMXE, "SMXE");
1688	REG_OUT_BIT(cr4, X86_CR4_PCIDE, "PCIDE");
1689	REG_OUT_BIT(cr4, X86_CR4_OSXSAVE, "OSXSAVE");
1690	REG_OUT_BIT(cr4, X86_CR4_SMEP, "SMEP");
1691	REG_OUT_BIT(cr4, X86_CR4_SMAP, "SMAP");
1692	REG_OUT_CLOSE(cr4);
1693	}
1694	else
1695	AssertMsgFailed(("Unknown x86 register specified in '%.10s'!\n", pszFormatOrg));
1696	}
1697	#endif
1698	else
1699	AssertMsgFailed(("Unknown architecture specified in '%.10s'!\n", pszFormatOrg));
1700	#undef REG_OUT_BIT
1701	#undef REG_OUT_CLOSE
1702	#undef REG_EQUALS
1703	return cchOutput;
1704	}
1705
1706	/*
1707	* Invalid/Unknown. Bitch about it.
1708	*/
1709	default:
1710	AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1711	break;
1712	}
1713	}
1714	else
1715	AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1716
1717	NOREF(pszFormatOrg);
1718	return 0;
1719	}
1720

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/string/strformatrt.cpp@ 84054

Download in other formats: