VirtualBox

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

最後變更 在這個檔案從84063是 84063,由 vboxsync 提交於 5 年 前

IPRT,++: New RTErrWin* API, data source unchanged. bugref:9726
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Id Revision
檔案大小: 77.6 KB
行 
1/* $Id: strformatrt.cpp 84063 2020-04-28 19:32:41Z 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.alldomusa.eu.org. 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*********************************************************************************************************************************/
63static char g_szHexDigits[17] = "0123456789abcdef";
64#ifdef IN_RING3
65static 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 */
76static 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 */
108static 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 */
234DECLHIDDEN(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# ifndef RT_OS_WINDOWS
1027 PCRTCOMERRMSG pMsg = RTErrCOMGet(hrc);
1028# endif
1029 switch (*(*ppszFormat)++)
1030 {
1031# ifdef RT_OS_WINDOWS
1032 case 'c':
1033 return RTErrWinFormatDefine(hrc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1034 case 'f':
1035 return RTErrWinFormatMsg(hrc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1036 case 'a':
1037 return RTErrWinFormatMsgAll(hrc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1038# else /* !RT_OS_WINDOWS */
1039 case 'c':
1040 return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
1041 case 'f':
1042 return pfnOutput(pvArgOutput, pMsg->pszMsgFull, strlen(pMsg->pszMsgFull));
1043 case 'a':
1044 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X) - %s", pMsg->pszDefine, hrc, pMsg->pszMsgFull);
1045# endif /* !RT_OS_WINDOWS */
1046 default:
1047 AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1048 return 0;
1049 }
1050 break;
1051 }
1052#endif /* IN_RING3 */
1053
1054 /*
1055 * Human readable sizes.
1056 */
1057 case 'c':
1058 case 'u':
1059 {
1060 unsigned i;
1061 ssize_t cchBuf;
1062 uint64_t uValue;
1063 uint64_t uFraction = 0;
1064 const char *pszPrefix = NULL;
1065 char ch2 = *(*ppszFormat)++;
1066 AssertMsgReturn(ch2 == 'b' || ch2 == 'B' || ch2 == 'i', ("invalid type '%.10s'!\n", pszFormatOrg), 0);
1067 uValue = va_arg(*pArgs, uint64_t);
1068
1069 if (!(fFlags & RTSTR_F_PRECISION))
1070 cchPrecision = 1; /** @todo default to flexible decimal point. */
1071 else if (cchPrecision > 3)
1072 cchPrecision = 3;
1073 else if (cchPrecision < 0)
1074 cchPrecision = 0;
1075
1076 if (ch2 == 'b' || ch2 == 'B')
1077 {
1078 static const struct
1079 {
1080 const char *pszPrefix;
1081 uint8_t cShift;
1082 uint64_t cbMin;
1083 uint64_t cbMinZeroPrecision;
1084 } s_aUnits[] =
1085 {
1086 { "Ei", 60, _1E, _1E*2 },
1087 { "Pi", 50, _1P, _1P*2 },
1088 { "Ti", 40, _1T, _1T*2 },
1089 { "Gi", 30, _1G, _1G64*2 },
1090 { "Mi", 20, _1M, _1M*2 },
1091 { "Ki", 10, _1K, _1K*2 },
1092 };
1093 for (i = 0; i < RT_ELEMENTS(s_aUnits); i++)
1094 if ( uValue >= s_aUnits[i].cbMin
1095 && (cchPrecision > 0 || uValue >= s_aUnits[i].cbMinZeroPrecision))
1096 {
1097 if (cchPrecision != 0)
1098 {
1099 uFraction = uValue & (RT_BIT_64(s_aUnits[i].cShift) - 1);
1100 uFraction *= cchPrecision == 1 ? 10 : cchPrecision == 2 ? 100 : 1000;
1101 uFraction >>= s_aUnits[i].cShift;
1102 }
1103 uValue >>= s_aUnits[i].cShift;
1104 pszPrefix = s_aUnits[i].pszPrefix;
1105 break;
1106 }
1107 }
1108 else
1109 {
1110 static const struct
1111 {
1112 const char *pszPrefix;
1113 uint64_t cbFactor;
1114 uint64_t cbMinZeroPrecision;
1115 } s_aUnits[] =
1116 {
1117 { "E", UINT64_C(1000000000000000000), UINT64_C(1010000000000000000), },
1118 { "P", UINT64_C(1000000000000000), UINT64_C(1010000000000000), },
1119 { "T", UINT64_C(1000000000000), UINT64_C(1010000000000), },
1120 { "G", UINT64_C(1000000000), UINT64_C(1010000000), },
1121 { "M", UINT64_C(1000000), UINT64_C(1010000), },
1122 { "k", UINT64_C(1000), UINT64_C(1010), },
1123 };
1124 for (i = 0; i < RT_ELEMENTS(s_aUnits); i++)
1125 if ( uValue >= s_aUnits[i].cbFactor
1126 && (cchPrecision > 0 || uValue >= s_aUnits[i].cbMinZeroPrecision))
1127 {
1128 if (cchPrecision == 0)
1129 uValue /= s_aUnits[i].cbFactor;
1130 else
1131 {
1132 uFraction = uValue % s_aUnits[i].cbFactor;
1133 uValue = uValue / s_aUnits[i].cbFactor;
1134 uFraction *= cchPrecision == 1 ? 10 : cchPrecision == 2 ? 100 : 1000;
1135 uFraction += s_aUnits[i].cbFactor >> 1;
1136 uFraction /= s_aUnits[i].cbFactor;
1137 }
1138 pszPrefix = s_aUnits[i].pszPrefix;
1139 break;
1140 }
1141 }
1142
1143 cchBuf = RTStrFormatU64(szBuf, sizeof(szBuf), uValue, 10, 0, 0, 0);
1144 if (pszPrefix)
1145 {
1146 if (cchPrecision)
1147 {
1148 szBuf[cchBuf++] = '.';
1149 cchBuf += RTStrFormatU64(&szBuf[cchBuf], sizeof(szBuf) - cchBuf, uFraction, 10, cchPrecision, 0,
1150 RTSTR_F_ZEROPAD | RTSTR_F_WIDTH);
1151 }
1152 if (fFlags & RTSTR_F_BLANK)
1153 szBuf[cchBuf++] = ' ';
1154 szBuf[cchBuf++] = *pszPrefix++;
1155 if (*pszPrefix && ch2 != 'B')
1156 szBuf[cchBuf++] = *pszPrefix;
1157 }
1158 else if (fFlags & RTSTR_F_BLANK)
1159 szBuf[cchBuf++] = ' ';
1160 if (ch == 'c')
1161 szBuf[cchBuf++] = 'B';
1162 szBuf[cchBuf] = '\0';
1163
1164 cch = 0;
1165 if ((fFlags & RTSTR_F_WIDTH) && !(fFlags & RTSTR_F_LEFT))
1166 while (cchBuf < cchWidth)
1167 {
1168 cch += pfnOutput(pvArgOutput, fFlags & RTSTR_F_ZEROPAD ? "0" : " ", 1);
1169 cchWidth--;
1170 }
1171 cch += pfnOutput(pvArgOutput, szBuf, cchBuf);
1172 return cch;
1173 }
1174
1175 default:
1176 AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1177 return 0;
1178
1179 }
1180 break;
1181 }
1182
1183 /*
1184 * iprt status code: %Rrc, %Rrs, %Rrf, %Rra.
1185 */
1186 case 'r':
1187 {
1188 int rc = va_arg(*pArgs, int);
1189#ifdef IN_RING3 /* we don't want this anywhere else yet. */
1190 switch (*(*ppszFormat)++)
1191 {
1192 case 'c':
1193 return RTErrFormatDefine(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1194 case 's':
1195 return RTErrFormatMsgShort(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1196 case 'f':
1197 return RTErrFormatMsgFull(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1198 case 'a':
1199 return RTErrFormatMsgAll(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1200 default:
1201 AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1202 return 0;
1203 }
1204#else /* !IN_RING3 */
1205 switch (*(*ppszFormat)++)
1206 {
1207 case 'c':
1208 case 's':
1209 case 'f':
1210 case 'a':
1211 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%d", rc);
1212 default:
1213 AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1214 return 0;
1215 }
1216#endif /* !IN_RING3 */
1217 break;
1218 }
1219
1220#if defined(IN_RING3)
1221 /*
1222 * Windows status code: %Rwc, %Rwf, %Rwa
1223 */
1224 case 'w':
1225 {
1226 long rc = va_arg(*pArgs, long);
1227 switch (*(*ppszFormat)++)
1228 {
1229# if defined(RT_OS_WINDOWS)
1230 case 'c':
1231 return RTErrWinFormatDefine(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1232 case 'f':
1233 return RTErrWinFormatMsg(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1234 case 'a':
1235 return RTErrWinFormatMsgAll(rc, pfnOutput, pvArgOutput, szBuf, sizeof(szBuf));
1236# else /* !RT_OS_WINDOWS */
1237 case 'c':
1238 case 'f':
1239 case 'a':
1240 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "0x%08x", rc);
1241# endif /* !RT_OS_WINDOWS */
1242 default:
1243 AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
1244 return 0;
1245 }
1246 break;
1247 }
1248#endif /* IN_RING3 */
1249
1250 /*
1251 * Group 4, structure dumpers.
1252 */
1253 case 'D':
1254 {
1255 /*
1256 * Interpret the type.
1257 */
1258 typedef enum
1259 {
1260 RTST_TIMESPEC
1261 } RTST;
1262/** Set if it's a pointer */
1263#define RTST_FLAGS_POINTER RT_BIT(0)
1264 static const struct
1265 {
1266 uint8_t cch; /**< the length of the string. */
1267 char sz[16-2]; /**< the part following 'R'. */
1268 uint8_t cb; /**< the size of the argument. */
1269 uint8_t fFlags; /**< RTST_FLAGS_* */
1270 RTST enmType; /**< The structure type. */
1271 }
1272 /** Sorted array of types, looked up using binary search! */
1273 s_aTypes[] =
1274 {
1275#define STRMEM(str) sizeof(str) - 1, str
1276 { STRMEM("Dtimespec"), sizeof(PCRTTIMESPEC), RTST_FLAGS_POINTER, RTST_TIMESPEC},
1277#undef STRMEM
1278 };
1279 const char *pszType = *ppszFormat - 1;
1280 int iStart = 0;
1281 int iEnd = RT_ELEMENTS(s_aTypes) - 1;
1282 int i = RT_ELEMENTS(s_aTypes) / 2;
1283
1284 union
1285 {
1286 const void *pv;
1287 uint64_t u64;
1288 PCRTTIMESPEC pTimeSpec;
1289 } u;
1290
1291 AssertMsg(!chArgSize, ("Not argument size '%c' for RT types! '%.10s'\n", chArgSize, pszFormatOrg));
1292
1293 /*
1294 * Lookup the type - binary search.
1295 */
1296 for (;;)
1297 {
1298 int iDiff = strncmp(pszType, s_aTypes[i].sz, s_aTypes[i].cch);
1299 if (!iDiff)
1300 break;
1301 if (iEnd == iStart)
1302 {
1303 AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
1304 return 0;
1305 }
1306 if (iDiff < 0)
1307 iEnd = i - 1;
1308 else
1309 iStart = i + 1;
1310 if (iEnd < iStart)
1311 {
1312 AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
1313 return 0;
1314 }
1315 i = iStart + (iEnd - iStart) / 2;
1316 }
1317 *ppszFormat += s_aTypes[i].cch - 1;
1318
1319 /*
1320 * Fetch the argument.
1321 */
1322 u.u64 = 0;
1323 switch (s_aTypes[i].cb)
1324 {
1325 case sizeof(const void *):
1326 u.pv = va_arg(*pArgs, const void *);
1327 break;
1328 default:
1329 AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
1330 break;
1331 }
1332
1333 /*
1334 * If it's a pointer, we'll check if it's valid before going on.
1335 */
1336 if ((s_aTypes[i].fFlags & RTST_FLAGS_POINTER) && !VALID_PTR(u.pv))
1337 return pfnOutput(pvArgOutput, RT_STR_TUPLE("<null>"));
1338
1339 /*
1340 * Format the output.
1341 */
1342 switch (s_aTypes[i].enmType)
1343 {
1344 case RTST_TIMESPEC:
1345 return RTStrFormat(pfnOutput, pvArgOutput, NULL, NULL, "%'lld ns", RTTimeSpecGetNano(u.pTimeSpec));
1346
1347 default:
1348 AssertMsgFailed(("Invalid/unhandled enmType=%d\n", s_aTypes[i].enmType));
1349 break;
1350 }
1351 break;
1352 }
1353
1354#ifdef IN_RING3
1355
1356 /*
1357 * Group 5, XML / HTML, JSON and URI escapers.
1358 */
1359 case 'M':
1360 {
1361 char chWhat = (*ppszFormat)[0];
1362 if (chWhat == 'a' || chWhat == 'e')
1363 {
1364 /* XML attributes and element values. */
1365 bool fAttr = chWhat == 'a';
1366 char chType = (*ppszFormat)[1];
1367 *ppszFormat += 2;
1368 switch (chType)
1369 {
1370 case 's':
1371 {
1372 static const char s_szElemEscape[] = "<>&\"'";
1373 static const char s_szAttrEscape[] = "<>&\"\n\r"; /* more? */
1374 const char * const pszEscape = fAttr ? s_szAttrEscape : s_szElemEscape;
1375 size_t const cchEscape = (fAttr ? RT_ELEMENTS(s_szAttrEscape) : RT_ELEMENTS(s_szElemEscape)) - 1;
1376 size_t cchOutput = 0;
1377 const char *pszStr = va_arg(*pArgs, char *);
1378 ssize_t cchStr;
1379 ssize_t offCur;
1380 ssize_t offLast;
1381
1382 if (!VALID_PTR(pszStr))
1383 pszStr = "<NULL>";
1384 cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
1385
1386 if (fAttr)
1387 cchOutput += pfnOutput(pvArgOutput, "\"", 1);
1388 if (!(fFlags & RTSTR_F_LEFT))
1389 while (--cchWidth >= cchStr)
1390 cchOutput += pfnOutput(pvArgOutput, " ", 1);
1391
1392 offLast = offCur = 0;
1393 while (offCur < cchStr)
1394 {
1395 if (memchr(pszEscape, pszStr[offCur], cchEscape))
1396 {
1397 if (offLast < offCur)
1398 cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1399 switch (pszStr[offCur])
1400 {
1401 case '<': cchOutput += pfnOutput(pvArgOutput, "&lt;", 4); break;
1402 case '>': cchOutput += pfnOutput(pvArgOutput, "&gt;", 4); break;
1403 case '&': cchOutput += pfnOutput(pvArgOutput, "&amp;", 5); break;
1404 case '\'': cchOutput += pfnOutput(pvArgOutput, "&apos;", 6); break;
1405 case '"': cchOutput += pfnOutput(pvArgOutput, "&quot;", 6); break;
1406 case '\n': cchOutput += pfnOutput(pvArgOutput, "&#xA;", 5); break;
1407 case '\r': cchOutput += pfnOutput(pvArgOutput, "&#xD;", 5); break;
1408 default:
1409 AssertFailed();
1410 }
1411 offLast = offCur + 1;
1412 }
1413 offCur++;
1414 }
1415 if (offLast < offCur)
1416 cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1417
1418 while (--cchWidth >= cchStr)
1419 cchOutput += pfnOutput(pvArgOutput, " ", 1);
1420 if (fAttr)
1421 cchOutput += pfnOutput(pvArgOutput, "\"", 1);
1422 return cchOutput;
1423 }
1424
1425 default:
1426 AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1427 }
1428 }
1429 else if (chWhat == 'j')
1430 {
1431 /* JSON string escaping. */
1432 char const chType = (*ppszFormat)[1];
1433 *ppszFormat += 2;
1434 switch (chType)
1435 {
1436 case 's':
1437 {
1438 const char *pszStr = va_arg(*pArgs, char *);
1439 size_t cchOutput;
1440 ssize_t cchStr;
1441 ssize_t offCur;
1442 ssize_t offLast;
1443
1444 if (!VALID_PTR(pszStr))
1445 pszStr = "<NULL>";
1446 cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
1447
1448 cchOutput = pfnOutput(pvArgOutput, "\"", 1);
1449 if (!(fFlags & RTSTR_F_LEFT))
1450 while (--cchWidth >= cchStr)
1451 cchOutput += pfnOutput(pvArgOutput, " ", 1);
1452
1453 offLast = offCur = 0;
1454 while (offCur < cchStr)
1455 {
1456 unsigned int const uch = pszStr[offCur];
1457 if ( uch >= 0x5d
1458 || (uch >= 0x20 && uch != 0x22 && uch != 0x5c))
1459 offCur++;
1460 else
1461 {
1462 if (offLast < offCur)
1463 cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1464 switch ((char)uch)
1465 {
1466 case '"': cchOutput += pfnOutput(pvArgOutput, "\\\"", 2); break;
1467 case '\\': cchOutput += pfnOutput(pvArgOutput, "\\\\", 2); break;
1468 case '/': cchOutput += pfnOutput(pvArgOutput, "\\/", 2); break;
1469 case '\b': cchOutput += pfnOutput(pvArgOutput, "\\b", 2); break;
1470 case '\f': cchOutput += pfnOutput(pvArgOutput, "\\f", 2); break;
1471 case '\n': cchOutput += pfnOutput(pvArgOutput, "\\n", 2); break;
1472 case '\t': cchOutput += pfnOutput(pvArgOutput, "\\t", 2); break;
1473 default:
1474 {
1475 RTUNICP uc = 0xfffd; /* replacement character */
1476 const char *pszCur = &pszStr[offCur];
1477 int rc = RTStrGetCpEx(&pszCur, &uc);
1478 if (RT_SUCCESS(rc))
1479 offCur += pszCur - &pszStr[offCur] - 1;
1480 if (uc >= 0xfffe)
1481 uc = 0xfffd; /* replacement character */
1482 szBuf[0] = '\\';
1483 szBuf[1] = 'u';
1484 szBuf[2] = g_szHexDigits[(uc >> 12) & 0xf];
1485 szBuf[3] = g_szHexDigits[(uc >> 8) & 0xf];
1486 szBuf[4] = g_szHexDigits[(uc >> 4) & 0xf];
1487 szBuf[5] = g_szHexDigits[ uc & 0xf];
1488 szBuf[6] = '\0';
1489 cchOutput += pfnOutput(pvArgOutput, szBuf, 6);
1490 break;
1491 }
1492 }
1493 offLast = ++offCur;
1494 }
1495 }
1496 if (offLast < offCur)
1497 cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1498
1499 while (--cchWidth >= cchStr)
1500 cchOutput += pfnOutput(pvArgOutput, " ", 1);
1501 cchOutput += pfnOutput(pvArgOutput, "\"", 1);
1502 return cchOutput;
1503 }
1504
1505 default:
1506 AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1507 }
1508 }
1509 else if (chWhat == 'p')
1510 {
1511 /* Percent encoded string (RTC-3986). */
1512 char const chVariant = (*ppszFormat)[1];
1513 char const chAddSafe = chVariant == 'p' ? '/'
1514 : chVariant == 'q' ? '+' /* '+' in queries is problematic, so no escape. */
1515 : '~' /* whatever */;
1516 size_t cchOutput = 0;
1517 const char *pszStr = va_arg(*pArgs, char *);
1518 ssize_t cchStr;
1519 ssize_t offCur;
1520 ssize_t offLast;
1521
1522 *ppszFormat += 2;
1523 AssertMsgBreak(chVariant == 'a' || chVariant == 'p' || chVariant == 'q' || chVariant == 'f',
1524 ("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1525
1526 if (!VALID_PTR(pszStr))
1527 pszStr = "<NULL>";
1528 cchStr = RTStrNLen(pszStr, (unsigned)cchPrecision);
1529
1530 if (!(fFlags & RTSTR_F_LEFT))
1531 while (--cchWidth >= cchStr)
1532 cchOutput += pfnOutput(pvArgOutput, "%20", 3);
1533
1534 offLast = offCur = 0;
1535 while (offCur < cchStr)
1536 {
1537 ch = pszStr[offCur];
1538 if ( RT_C_IS_ALPHA(ch)
1539 || RT_C_IS_DIGIT(ch)
1540 || ch == '-'
1541 || ch == '.'
1542 || ch == '_'
1543 || ch == '~'
1544 || ch == chAddSafe)
1545 offCur++;
1546 else
1547 {
1548 if (offLast < offCur)
1549 cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1550 if (ch != ' ' || chVariant != 'f')
1551 {
1552 szBuf[0] = '%';
1553 szBuf[1] = g_szHexDigitsUpper[((uint8_t)ch >> 4) & 0xf];
1554 szBuf[2] = g_szHexDigitsUpper[(uint8_t)ch & 0xf];
1555 szBuf[3] = '\0';
1556 cchOutput += pfnOutput(pvArgOutput, szBuf, 3);
1557 }
1558 else
1559 cchOutput += pfnOutput(pvArgOutput, "+", 1);
1560 offLast = ++offCur;
1561 }
1562 }
1563 if (offLast < offCur)
1564 cchOutput += pfnOutput(pvArgOutput, &pszStr[offLast], offCur - offLast);
1565
1566 while (--cchWidth >= cchStr)
1567 cchOutput += pfnOutput(pvArgOutput, "%20", 3);
1568 }
1569 else
1570 AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1571 break;
1572 }
1573
1574#endif /* IN_RING3 */
1575
1576 /*
1577 * Groups 6 - CPU Architecture Register Formatters.
1578 * "%RAarch[reg]"
1579 */
1580 case 'A':
1581 {
1582 char const * const pszArch = *ppszFormat;
1583 const char *pszReg = pszArch;
1584 size_t cchOutput = 0;
1585 int cPrinted = 0;
1586 size_t cchReg;
1587
1588 /* Parse out the */
1589 while ((ch = *pszReg++) && ch != '[')
1590 { /* nothing */ }
1591 AssertMsgBreak(ch == '[', ("Malformed IPRT architecture register format type '%.10s'!\n", pszFormatOrg));
1592
1593 cchReg = 0;
1594 while ((ch = pszReg[cchReg]) && ch != ']')
1595 cchReg++;
1596 AssertMsgBreak(ch == ']', ("Malformed IPRT architecture register format type '%.10s'!\n", pszFormatOrg));
1597
1598 *ppszFormat = &pszReg[cchReg + 1];
1599
1600
1601#define REG_EQUALS(a_szReg) (sizeof(a_szReg) - 1 == cchReg && !strncmp(a_szReg, pszReg, sizeof(a_szReg) - 1))
1602#define REG_OUT_BIT(a_uVal, a_fBitMask, a_szName) \
1603 do { \
1604 if ((a_uVal) & (a_fBitMask)) \
1605 { \
1606 if (!cPrinted++) \
1607 cchOutput += pfnOutput(pvArgOutput, "{" a_szName, sizeof(a_szName)); \
1608 else \
1609 cchOutput += pfnOutput(pvArgOutput, "," a_szName, sizeof(a_szName)); \
1610 (a_uVal) &= ~(a_fBitMask); \
1611 } \
1612 } while (0)
1613#define REG_OUT_CLOSE(a_uVal) \
1614 do { \
1615 if ((a_uVal)) \
1616 { \
1617 cchOutput += pfnOutput(pvArgOutput, !cPrinted ? "{unkn=" : ",unkn=", 6); \
1618 cch = RTStrFormatNumber(&szBuf[0], (a_uVal), 16, 1, -1, fFlags); \
1619 cchOutput += pfnOutput(pvArgOutput, szBuf, cch); \
1620 cPrinted++; \
1621 } \
1622 if (cPrinted) \
1623 cchOutput += pfnOutput(pvArgOutput, "}", 1); \
1624 } while (0)
1625
1626
1627 if (0)
1628 { /* dummy */ }
1629#ifdef STRFORMAT_WITH_X86
1630 /*
1631 * X86 & AMD64.
1632 */
1633 else if ( pszReg - pszArch == 3 + 1
1634 && pszArch[0] == 'x'
1635 && pszArch[1] == '8'
1636 && pszArch[2] == '6')
1637 {
1638 if (REG_EQUALS("cr0"))
1639 {
1640 uint64_t cr0 = va_arg(*pArgs, uint64_t);
1641 fFlags |= RTSTR_F_64BIT;
1642 cch = RTStrFormatNumber(&szBuf[0], cr0, 16, 8, -1, fFlags | RTSTR_F_ZEROPAD);
1643 cchOutput += pfnOutput(pvArgOutput, szBuf, cch);
1644 REG_OUT_BIT(cr0, X86_CR0_PE, "PE");
1645 REG_OUT_BIT(cr0, X86_CR0_MP, "MP");
1646 REG_OUT_BIT(cr0, X86_CR0_EM, "EM");
1647 REG_OUT_BIT(cr0, X86_CR0_TS, "DE");
1648 REG_OUT_BIT(cr0, X86_CR0_ET, "ET");
1649 REG_OUT_BIT(cr0, X86_CR0_NE, "NE");
1650 REG_OUT_BIT(cr0, X86_CR0_WP, "WP");
1651 REG_OUT_BIT(cr0, X86_CR0_AM, "AM");
1652 REG_OUT_BIT(cr0, X86_CR0_NW, "NW");
1653 REG_OUT_BIT(cr0, X86_CR0_CD, "CD");
1654 REG_OUT_BIT(cr0, X86_CR0_PG, "PG");
1655 REG_OUT_CLOSE(cr0);
1656 }
1657 else if (REG_EQUALS("cr4"))
1658 {
1659 uint64_t cr4 = va_arg(*pArgs, uint64_t);
1660 fFlags |= RTSTR_F_64BIT;
1661 cch = RTStrFormatNumber(&szBuf[0], cr4, 16, 8, -1, fFlags | RTSTR_F_ZEROPAD);
1662 cchOutput += pfnOutput(pvArgOutput, szBuf, cch);
1663 REG_OUT_BIT(cr4, X86_CR4_VME, "VME");
1664 REG_OUT_BIT(cr4, X86_CR4_PVI, "PVI");
1665 REG_OUT_BIT(cr4, X86_CR4_TSD, "TSD");
1666 REG_OUT_BIT(cr4, X86_CR4_DE, "DE");
1667 REG_OUT_BIT(cr4, X86_CR4_PSE, "PSE");
1668 REG_OUT_BIT(cr4, X86_CR4_PAE, "PAE");
1669 REG_OUT_BIT(cr4, X86_CR4_MCE, "MCE");
1670 REG_OUT_BIT(cr4, X86_CR4_PGE, "PGE");
1671 REG_OUT_BIT(cr4, X86_CR4_PCE, "PCE");
1672 REG_OUT_BIT(cr4, X86_CR4_OSFXSR, "OSFXSR");
1673 REG_OUT_BIT(cr4, X86_CR4_OSXMMEEXCPT, "OSXMMEEXCPT");
1674 REG_OUT_BIT(cr4, X86_CR4_VMXE, "VMXE");
1675 REG_OUT_BIT(cr4, X86_CR4_SMXE, "SMXE");
1676 REG_OUT_BIT(cr4, X86_CR4_PCIDE, "PCIDE");
1677 REG_OUT_BIT(cr4, X86_CR4_OSXSAVE, "OSXSAVE");
1678 REG_OUT_BIT(cr4, X86_CR4_SMEP, "SMEP");
1679 REG_OUT_BIT(cr4, X86_CR4_SMAP, "SMAP");
1680 REG_OUT_CLOSE(cr4);
1681 }
1682 else
1683 AssertMsgFailed(("Unknown x86 register specified in '%.10s'!\n", pszFormatOrg));
1684 }
1685#endif
1686 else
1687 AssertMsgFailed(("Unknown architecture specified in '%.10s'!\n", pszFormatOrg));
1688#undef REG_OUT_BIT
1689#undef REG_OUT_CLOSE
1690#undef REG_EQUALS
1691 return cchOutput;
1692 }
1693
1694 /*
1695 * Invalid/Unknown. Bitch about it.
1696 */
1697 default:
1698 AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1699 break;
1700 }
1701 }
1702 else
1703 AssertMsgFailed(("Invalid IPRT format type '%.10s'!\n", pszFormatOrg));
1704
1705 NOREF(pszFormatOrg);
1706 return 0;
1707}
1708
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette