strformatrt.cpp@ 4968

Last change on this file since 4968 was 4908, checked in by vboxsync, 17 years ago
Cify since we use these two files in Linux kernel modules
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 34.8 KB

Line
1	/* $Id: strformatrt.cpp 4908 2007-09-20 07:23:11Z vboxsync $ */
2	/** @file
3	* innotek Portable Runtime - IPRT String Formatter Extensions.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/** @page pg_rt_str_format_rt The IPRT String Format Extensions
19	*
20	* The string formatter supports most of the non-float format types and flags.
21	* See RTStrFormatV() for the full tail there. In addition we've added a number
22	* of iprt specific format types for the iprt typedefs and other useful stuff.
23	* Note that several of these are similar to \%p and doesn't care much if you try
24	* add formating flags/width/precision.
25	*
26	*
27	* Group 1, the basic runtime typedefs (excluding those which obviously are pointer).
28	* - \%RTbool - Takes a bool value and prints 'true', 'false', or '!%d!'.
29	* - \%RTfile - Takes a #RTFILE value.
30	* - \%RTfmode - Takes a #RTFMODE value.
31	* - \%RTfoff - Takes a #RTFOFF value.
32	* - \%RTfp16 - Takes a #RTFAR16 value.
33	* - \%RTfp32 - Takes a #RTFAR32 value.
34	* - \%RTfp64 - Takes a #RTFAR64 value.
35	* - \%RTgid - Takes a #RTGID value.
36	* - \%RTino - Takes a #RTINODE value.
37	* - \%RTint - Takes a #RTINT value.
38	* - \%RTiop - Takes a #RTIOPORT value.
39	* - \%RTldrm - Takes a #RTLDRMOD value.
40	* - \%RTnthrd - Takes a #RTNATIVETHREAD value.
41	* - \%RTproc - Takes a #RTPROCESS value.
42	* - \%RTptr - Takes a #RTINTPTR or #RTUINTPTR value (but not void *).
43	* - \%RTreg - Takes a #RTUINTREG value.
44	* - \%RTsel - Takes a #RTSEL value.
45	* - \%RTsem - Takes a #RTSEMEVENT, #RTSEMEVENTMULTI, #RTSEMMUTEX, #RTSEMFASTMUTEX, or #RTSEMRW value.
46	* - \%RTsock - Takes a #RTSOCKET value.
47	* - \%RTthrd - Takes a #RTTHREAD value.
48	* - \%RTuid - Takes a #RTUID value.
49	* - \%RTuint - Takes a #RTUINT value.
50	* - \%RTunicp - Takes a #RTUNICP value.
51	* - \%RTutf16 - Takes a #RTUTF16 value.
52	* - \%RTuuid - Takes a #PCRTUUID and will print the UUID as a string.
53	* - \%RTxuint - Takes a #RTUINT or #RTINT value, formatting it as hex.
54	* - \%RGi - Takes a #RTGCINT value.
55	* - \%RGp - Takes a #RTGCPHYS value.
56	* - \%RGr - Takes a #RTGCUINTREG value.
57	* - \%RGu - Takes a #RTGCUINT value.
58	* - \%RGv - Takes a #RTGCPTR, #RTGCINTPTR or #RTGCUINTPTR value.
59	* - \%RGx - Takes a #RTGCUINT or #RTGCINT value, formatting it as hex.
60	* - \%RHi - Takes a #RTHCINT value.
61	* - \%RHp - Takes a #RTHCPHYS value.
62	* - \%RHr - Takes a #RTHCUINTREG value.
63	* - \%RHu - Takes a #RTHCUINT value.
64	* - \%RHv - Takes a #RTHCPTR, #RTHCINTPTR or #RTHCUINTPTR value.
65	* - \%RHx - Takes a #RTHCUINT or #RTHCINT value, formatting it as hex.
66	* - \%RCi - Takes a #RTCCINT value.
67	* - \%RCp - Takes a #RTCCPHYS value.
68	* - \%RCr - Takes a #RTCCUINTREG value.
69	* - \%RCu - Takes a #RTUINT value.
70	* - \%RCv - Takes a #uintptr_t, #intptr_t, void * value.
71	* - \%RCx - Takes a #RTUINT or #RTINT value, formatting it as hex.
72	*
73	*
74	* Group 2, the generic integer types which are prefered over relying on what
75	* bit-count a 'long', 'short', or 'long long' has on a platform. This are
76	* highly prefered for the [u]intXX_t kind of types.
77	* - \%RI[8\|16\|32\|64] - Signed integer value of the specifed bit count.
78	* - \%RU[8\|16\|32\|64] - Unsigned integer value of the specifed bit count.
79	* - \%RX[8\|16\|32\|64] - Hexadecimal integer value of the specifed bit count.
80	*
81	*
82	* Group 3, hex dumpers and other complex stuff which requires more than simple formatting.
83	* - \%Rhxd - Takes a pointer to the memory which is to be dumped in typical
84	* hex format. Use the width to specify the length, and the precision to
85	* set the number of bytes per line. Default width and precision is 16.
86	* - \%Rhxs - Takes a pointer to the memory to be displayed as a hex string,
87	* i.e. a series of space separated bytes formatted as two digit hex value.
88	* Use the width to specify the length. Default length is 16 bytes.
89	* - \%Rrc - Takes an integer iprt status code as argument. Will insert the
90	* status code define corresponding to the iprt status code.
91	* - \%Rrs - Takes an integer iprt status code as argument. Will insert the
92	* short description of the specified status code.
93	* - \%Rrf - Takes an integer iprt status code as argument. Will insert the
94	* full description of the specified status code.
95	* - \%Rra - Takes an integer iprt status code as argument. Will insert the
96	* status code define + full description.
97	* - \%Rt - Current thread (RTThreadSelf()), no arguments.
98	*
99	* - \%Rwc - Takes a long Windows error code as argument. Will insert the status
100	* code define corresponding to the Windows error code.
101	* - \%Rwf - Takes a long Windows error code as argument. Will insert the
102	* full description of the specified status code.
103	* - \%Rwa - Takes a long Windows error code as argument. Will insert the
104	* error code define + full description.
105	*
106	* On other platforms, \%Rw? simply prints the argument in a form of 0xXXXXXXXX.
107	*
108	* @todo (r=dmik) Add a cross-platform \%Rcomr? that will fall back to \%Rw? on
109	* Win32 platforms and will interpret XPCOM result codes on all other.
110	*
111	*
112	* Group 4, structure dumpers.
113	*
114	* - \%RDtimespec - Takes a PCRTTIMESPEC.
115	*
116	*
117	*/
118
119	/*******************************************************************************
120	* Header Files *
121	*******************************************************************************/
122	#define LOG_GROUP RTLOGGROUP_STRING
123	#include <iprt/log.h>
124	#include <iprt/string.h>
125	#include <iprt/assert.h>
126	#include <iprt/string.h>
127	#include <iprt/stdarg.h>
128	#ifdef IN_RING3
129	# include <iprt/thread.h>
130	# include <iprt/err.h>
131	#endif
132	#include <iprt/time.h>
133	#include "internal/string.h"
134
135
136
137	/**
138	* Callback to format iprt formatting extentions.
139	* See @ref pg_rt_str_format_rt for a reference on the format types.
140	*
141	* @returns The number of bytes formatted.
142	* @param pfnOutput Pointer to output function.
143	* @param pvArgOutput Argument for the output function.
144	* @param ppszFormat Pointer to the format string pointer. Advance this till the char
145	* after the format specifier.
146	* @param pArgs Pointer to the argument list. Use this to fetch the arguments.
147	* @param cchWidth Format Width. -1 if not specified.
148	* @param cchPrecision Format Precision. -1 if not specified.
149	* @param fFlags Flags (RTSTR_NTFS_*).
150	* @param chArgSize The argument size specifier, 'l' or 'L'.
151	*/
152	size_t rtstrFormatRt(PFNRTSTROUTPUT pfnOutput, void pvArgOutput, const char ppszFormat, va_list pArgs, int cchWidth, int cchPrecision, unsigned fFlags, char chArgSize)
153	{
154	const char pszFormatOrg = ppszFormat;
155	char ch = (ppszFormat)++;
156	if (ch == 'R')
157	{
158	ch = (ppszFormat)++;
159	switch (ch)
160	{
161	/*
162	* Groups 1 and 2.
163	*/
164	case 'T':
165	case 'G':
166	case 'H':
167	case 'C':
168	case 'I':
169	case 'X':
170	case 'U':
171	{
172	/*
173	* Interpret the type.
174	*/
175	typedef enum { RTSF_INT, RTSF_INTW, RTSF_FP16, RTSF_FP32, RTSF_FP64, RTSF_UUID, RTSF_BOOL } RTSF;
176	static const struct
177	{
178	uint8_t cch; /*< the length of the string. /
179	char sz[10]; /*< the part following 'R'. /
180	uint8_t cb; /*< the size of the type. /
181	uint8_t u8Base; /*< the size of the type. /
182	RTSF enmFormat; /*< The way to format it. /
183	uint16_t fFlags; /*< additional RTSTR_F_ flags. */
184	}
185	/** Sorted array of types, looked up using binary search! */
186	s_aTypes[] =
187	{
188	#define STRMEM(str) sizeof(str) - 1, str
189	{ STRMEM("Ci"), sizeof(RTINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
190	{ STRMEM("Cp"), sizeof(RTGCPHYS), 16, RTSF_INTW, 0 },
191	{ STRMEM("Cr"), sizeof(RTCCUINTREG), 16, RTSF_INTW, 0 },
192	{ STRMEM("Cu"), sizeof(RTUINT), 10, RTSF_INT, 0 },
193	{ STRMEM("Cv"), sizeof(void *), 16, RTSF_INTW, 0 },
194	{ STRMEM("Cx"), sizeof(RTUINT), 16, RTSF_INT, 0 },
195	{ STRMEM("Gi"), sizeof(RTGCINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
196	{ STRMEM("Gp"), sizeof(RTGCPHYS), 16, RTSF_INTW, 0 },
197	{ STRMEM("Gr"), sizeof(RTGCUINTREG), 16, RTSF_INTW, 0 },
198	{ STRMEM("Gu"), sizeof(RTGCUINT), 10, RTSF_INT, 0 },
199	{ STRMEM("Gv"), sizeof(RTGCPTR), 16, RTSF_INTW, 0 },
200	{ STRMEM("Gx"), sizeof(RTGCUINT), 16, RTSF_INT, 0 },
201	{ STRMEM("Hi"), sizeof(RTHCINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
202	{ STRMEM("Hp"), sizeof(RTHCPHYS), 16, RTSF_INTW, 0 },
203	{ STRMEM("Hr"), sizeof(RTGCUINTREG), 16, RTSF_INTW, 0 },
204	{ STRMEM("Hu"), sizeof(RTHCUINT), 10, RTSF_INT, 0 },
205	{ STRMEM("Hv"), sizeof(RTHCPTR), 16, RTSF_INTW, 0 },
206	{ STRMEM("Hx"), sizeof(RTHCUINT), 16, RTSF_INT, 0 },
207	{ STRMEM("I16"), sizeof(int16_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
208	{ STRMEM("I32"), sizeof(int32_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
209	{ STRMEM("I64"), sizeof(int64_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
210	{ STRMEM("I8"), sizeof(int8_t), 10, RTSF_INT, RTSTR_F_VALSIGNED },
211	{ STRMEM("Tbool"), sizeof(bool), 10, RTSF_BOOL, 0 },
212	{ STRMEM("Tfile"), sizeof(RTFILE), 10, RTSF_INT, 0 },
213	{ STRMEM("Tfmode"), sizeof(RTFMODE), 16, RTSF_INTW, 0 },
214	{ STRMEM("Tfoff"), sizeof(RTFOFF), 10, RTSF_INT, RTSTR_F_VALSIGNED },
215	{ STRMEM("Tfp16"), sizeof(RTFAR16), 16, RTSF_FP16, RTSTR_F_ZEROPAD },
216	{ STRMEM("Tfp32"), sizeof(RTFAR32), 16, RTSF_FP32, RTSTR_F_ZEROPAD },
217	{ STRMEM("Tfp64"), sizeof(RTFAR64), 16, RTSF_FP64, RTSTR_F_ZEROPAD },
218	{ STRMEM("Tgid"), sizeof(RTGID), 10, RTSF_INT, RTSTR_F_VALSIGNED },
219	{ STRMEM("Tino"), sizeof(RTINODE), 16, RTSF_INTW, 0 },
220	{ STRMEM("Tint"), sizeof(RTINT), 10, RTSF_INT, RTSTR_F_VALSIGNED },
221	{ STRMEM("Tiop"), sizeof(RTIOPORT), 16, RTSF_INTW, 0 },
222	{ STRMEM("Tldrm"), sizeof(RTLDRMOD), 16, RTSF_INTW, 0 },
223	{ STRMEM("Tnthrd"), sizeof(RTNATIVETHREAD), 16, RTSF_INTW, 0 },
224	{ STRMEM("Tproc"), sizeof(RTPROCESS), 16, RTSF_INTW, 0 },
225	{ STRMEM("Tptr"), sizeof(RTUINTPTR), 16, RTSF_INTW, 0 },
226	{ STRMEM("Treg"), sizeof(RTUINTREG), 16, RTSF_INTW, 0 },
227	{ STRMEM("Tsel"), sizeof(RTSEL), 16, RTSF_INTW, 0 },
228	{ STRMEM("Tsem"), sizeof(RTSEMEVENT), 16, RTSF_INTW, 0 },
229	{ STRMEM("Tsock"), sizeof(RTSOCKET), 10, RTSF_INT, 0 },
230	{ STRMEM("Tthrd"), sizeof(RTTHREAD), 16, RTSF_INTW, 0 },
231	{ STRMEM("Tuid"), sizeof(RTUID), 10, RTSF_INT, RTSTR_F_VALSIGNED },
232	{ STRMEM("Tuint"), sizeof(RTUINT), 10, RTSF_INT, 0 },
233	{ STRMEM("Tunicp"), sizeof(RTUNICP), 16, RTSF_INTW, RTSTR_F_ZEROPAD },
234	{ STRMEM("Tutf16"), sizeof(RTUTF16), 16, RTSF_INTW, RTSTR_F_ZEROPAD },
235	{ STRMEM("Tuuid"), sizeof(PCRTUUID), 16, RTSF_UUID, 0 },
236	{ STRMEM("Txint"), sizeof(RTUINT), 16, RTSF_INT, 0 },
237	{ STRMEM("U16"), sizeof(uint16_t), 10, RTSF_INT, 0 },
238	{ STRMEM("U32"), sizeof(uint32_t), 10, RTSF_INT, 0 },
239	{ STRMEM("U64"), sizeof(uint64_t), 10, RTSF_INT, 0 },
240	{ STRMEM("U8"), sizeof(uint8_t), 10, RTSF_INT, 0 },
241	{ STRMEM("X16"), sizeof(uint16_t), 16, RTSF_INT, 0 },
242	{ STRMEM("X32"), sizeof(uint32_t), 16, RTSF_INT, 0 },
243	{ STRMEM("X64"), sizeof(uint64_t), 16, RTSF_INT, 0 },
244	{ STRMEM("X8"), sizeof(uint8_t), 16, RTSF_INT, 0 },
245	#undef STRMEM
246	};
247	const char pszType = ppszFormat - 1;
248	int iStart = 0;
249	int iEnd = ELEMENTS(s_aTypes) - 1;
250	int i = ELEMENTS(s_aTypes) / 2;
251
252	union
253	{
254	uint8_t u8;
255	uint16_t u16;
256	uint32_t u32;
257	uint64_t u64;
258	int8_t i8;
259	int16_t i16;
260	int32_t i32;
261	int64_t i64;
262	RTFAR16 fp16;
263	RTFAR32 fp32;
264	RTFAR64 fp64;
265	bool fBool;
266	PCRTUUID pUuid;
267	} u;
268	char szBuf[80];
269	unsigned cch;
270
271	AssertMsg(!chArgSize, ("Not argument size '%c' for RT types! '%.10s'\n", chArgSize, pszFormatOrg));
272
273	/*
274	* Lookup the type - binary search.
275	*/
276	for (;;)
277	{
278	int iDiff = strncmp(pszType, s_aTypes[i].sz, s_aTypes[i].cch);
279	if (!iDiff)
280	break;
281	if (iEnd == iStart)
282	{
283	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
284	return 0;
285	}
286	if (iDiff < 0)
287	iEnd = i - 1;
288	else
289	iStart = i + 1;
290	if (iEnd < iStart)
291	{
292	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
293	return 0;
294	}
295	i = iStart + (iEnd - iStart) / 2;
296	}
297
298	/*
299	* Advance the format string and merge flags.
300	*/
301	*ppszFormat += s_aTypes[i].cch - 1;
302	fFlags \|= s_aTypes[i].fFlags;
303
304	/*
305	* Fetch the argument.
306	* It's important that a signed value gets sign-extended up to 64-bit.
307	*/
308	u.u64 = 0;
309	if (fFlags & RTSTR_F_VALSIGNED)
310	{
311	switch (s_aTypes[i].cb)
312	{
313	case sizeof(int8_t):
314	u.i64 = va_arg(pArgs, /int8_t*/int);
315	fFlags \|= RTSTR_F_8BIT;
316	break;
317	case sizeof(int16_t):
318	u.i64 = va_arg(pArgs, /int16_t*/int);
319	fFlags \|= RTSTR_F_16BIT;
320	break;
321	case sizeof(int32_t):
322	u.i64 = va_arg(*pArgs, int32_t);
323	fFlags \|= RTSTR_F_32BIT;
324	break;
325	case sizeof(int64_t):
326	u.i64 = va_arg(*pArgs, int64_t);
327	fFlags \|= RTSTR_F_64BIT;
328	break;
329	default:
330	AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
331	break;
332	}
333	}
334	else
335	{
336	switch (s_aTypes[i].cb)
337	{
338	case sizeof(uint8_t):
339	u.u8 = va_arg(pArgs, /uint8_t*/unsigned);
340	fFlags \|= RTSTR_F_8BIT;
341	break;
342	case sizeof(uint16_t):
343	u.u16 = va_arg(pArgs, /uint16_t*/unsigned);
344	fFlags \|= RTSTR_F_16BIT;
345	break;
346	case sizeof(uint32_t):
347	u.u32 = va_arg(*pArgs, uint32_t);
348	fFlags \|= RTSTR_F_32BIT;
349	break;
350	case sizeof(uint64_t):
351	u.u64 = va_arg(*pArgs, uint64_t);
352	fFlags \|= RTSTR_F_64BIT;
353	break;
354	case sizeof(RTFAR32):
355	u.fp32 = va_arg(*pArgs, RTFAR32);
356	break;
357	case sizeof(RTFAR64):
358	u.fp64 = va_arg(*pArgs, RTFAR64);
359	break;
360	default:
361	AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
362	break;
363	}
364	}
365
366	/*
367	* Format the output.
368	*/
369	switch (s_aTypes[i].enmFormat)
370	{
371	case RTSF_INT:
372	{
373	cch = RTStrFormatNumber(szBuf, u.u64, s_aTypes[i].u8Base, cchWidth, cchPrecision, fFlags);
374	break;
375	}
376
377	/* hex which defaults to max width. */
378	case RTSF_INTW:
379	{
380	Assert(s_aTypes[i].u8Base == 16);
381	if (cchWidth < 0)
382	{
383	cchWidth = s_aTypes[i].cb * 2 + (fFlags & RTSTR_F_SPECIAL ? 2 : 0);
384	fFlags \|= RTSTR_F_ZEROPAD;
385	}
386	cch = RTStrFormatNumber(szBuf, u.u64, s_aTypes[i].u8Base, cchWidth, cchPrecision, fFlags);
387	break;
388	}
389
390	case RTSF_FP16:
391	{
392	fFlags &= ~(RTSTR_F_VALSIGNED \| RTSTR_F_BIT_MASK \| RTSTR_F_WIDTH \| RTSTR_F_PRECISION);
393	cch = RTStrFormatNumber(&szBuf[0], u.fp16.sel, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
394	Assert(cch == 4);
395	szBuf[4] = ':';
396	cch = RTStrFormatNumber(&szBuf[5], u.fp16.off, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
397	Assert(cch == 4);
398	cch = 4 + 1 + 4;
399	break;
400	}
401	case RTSF_FP32:
402	{
403	fFlags &= ~(RTSTR_F_VALSIGNED \| RTSTR_F_BIT_MASK \| RTSTR_F_WIDTH \| RTSTR_F_PRECISION);
404	cch = RTStrFormatNumber(&szBuf[0], u.fp32.sel, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
405	Assert(cch == 4);
406	szBuf[4] = ':';
407	cch = RTStrFormatNumber(&szBuf[5], u.fp32.off, 16, 8, -1, fFlags \| RTSTR_F_32BIT);
408	Assert(cch == 8);
409	cch = 4 + 1 + 8;
410	break;
411	}
412	case RTSF_FP64:
413	{
414	fFlags &= ~(RTSTR_F_VALSIGNED \| RTSTR_F_BIT_MASK \| RTSTR_F_WIDTH \| RTSTR_F_PRECISION);
415	cch = RTStrFormatNumber(&szBuf[0], u.fp64.sel, 16, 4, -1, fFlags \| RTSTR_F_16BIT);
416	Assert(cch == 4);
417	szBuf[4] = ':';
418	cch = RTStrFormatNumber(&szBuf[5], u.fp64.off, 16, 16, -1, fFlags \| RTSTR_F_64BIT);
419	Assert(cch == 16);
420	cch = 4 + 1 + 16;
421	break;
422	}
423
424	case RTSF_UUID:
425	{
426	static const char szNull[] = "<NULL>";
427
428	if (VALID_PTR(u.pUuid))
429	{
430	/* cannot call RTUuidToStr because of GC/R0. */
431	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
432	"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
433	u.pUuid->Gen.u32TimeLow,
434	u.pUuid->Gen.u16TimeMid,
435	u.pUuid->Gen.u16TimeHiAndVersion,
436	u.pUuid->Gen.u16ClockSeq & 0xff,
437	u.pUuid->Gen.u16ClockSeq >> 8,
438	u.pUuid->Gen.au8Node[0],
439	u.pUuid->Gen.au8Node[1],
440	u.pUuid->Gen.au8Node[2],
441	u.pUuid->Gen.au8Node[3],
442	u.pUuid->Gen.au8Node[4],
443	u.pUuid->Gen.au8Node[5]);
444	}
445	return pfnOutput(pvArgOutput, szNull, sizeof(szNull) - 1);
446	}
447
448	case RTSF_BOOL:
449	{
450	static const char szTrue[] = "true ";
451	static const char szFalse[] = "false";
452	if (u.u64 == 1)
453	return pfnOutput(pvArgOutput, szTrue, sizeof(szTrue) - 1);
454	if (u.u64 == 0)
455	return pfnOutput(pvArgOutput, szFalse, sizeof(szFalse) - 1);
456	/* invalid boolean value */
457	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "!%lld!", u.u64);
458	}
459
460	default:
461	AssertMsgFailed(("Internal error %d\n", s_aTypes[i].enmFormat));
462	return 0;
463	}
464
465	/*
466	* Finally, output the formatted string and return.
467	*/
468	return pfnOutput(pvArgOutput, szBuf, cch);
469	}
470
471
472	/* Group 3 */
473
474	/*
475	* hex dumping.
476	*/
477	case 'h':
478	{
479	char ch = (ppszFormat)++;
480	switch (ch)
481	{
482	/*
483	* Hex stuff.
484	*/
485	case 'x':
486	{
487	uint8_t pu8 = va_arg(pArgs, uint8_t *);
488	if (cchWidth <= 0)
489	cchWidth = 16;
490	if (pu8)
491	{
492	ch = (ppszFormat)++;
493	switch (ch)
494	{
495	/*
496	* Regular hex dump.
497	*/
498	case 'd':
499	{
500	size_t cch = 0;
501	int off = 0;
502
503	if (cchPrecision <= 0)
504	cchPrecision = 16;
505
506	while (off < cchWidth)
507	{
508	int i;
509	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s%0x %04x:", off ? "\n" : "", sizeof(pu8) 2, (uintptr_t)pu8, off);
510	for (i = 0; i < cchPrecision && off + i < cchWidth ; i++)
511	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
512	off + i < cchWidth ? !(i & 7) && i ? "-%02x" : " %02x" : " ", pu8[i]);
513	while (i++ < cchPrecision)
514	cch += pfnOutput(pvArgOutput, " ", 3);
515
516	cch += pfnOutput(pvArgOutput, " ", 1);
517
518	for (i = 0; i < cchPrecision && off + i < cchWidth; i++)
519	{
520	uint8_t u8 = pu8[i];
521	cch += pfnOutput(pvArgOutput, u8 < 127 && u8 >= 32 ? (const char *)&u8 : ".", 1);
522	}
523
524	/* next */
525	pu8 += cchPrecision;
526	off += cchPrecision;
527	}
528	return cch;
529	}
530
531	/*
532	* Hex string.
533	*/
534	case 's':
535	{
536	if (cchWidth-- > 0)
537	{
538	size_t cch = RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%02x", *pu8++);
539	for (; cchWidth > 0; cchWidth--, pu8++)
540	cch += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, " %02x", *pu8);
541	return cch;
542	}
543	break;
544	}
545
546	default:
547	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", ch, pszFormatOrg));
548	break;
549	}
550	}
551	else
552	return pfnOutput(pvArgOutput, "<null>", sizeof("<null>") - 1);
553	break;
554	}
555
556	default:
557	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", ch, pszFormatOrg));
558	return 0;
559
560	}
561	break;
562	}
563
564	/*
565	* iprt status code: %Vrc, %Vrs, %Vrf, %Vra.
566	*/
567	case 'r':
568	{
569	int rc = va_arg(*pArgs, int);
570	char ch = (ppszFormat)++;
571	#ifdef IN_RING3 /* we don't want this anywhere else yet. */
572	PCRTSTATUSMSG pMsg = RTErrGet(rc);
573	switch (ch)
574	{
575	case 'c':
576	return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
577	case 's':
578	return pfnOutput(pvArgOutput, pMsg->pszMsgShort, strlen(pMsg->pszMsgShort));
579	case 'f':
580	return pfnOutput(pvArgOutput, pMsg->pszMsgFull, strlen(pMsg->pszMsgFull));
581	case 'a':
582	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (%d) - %s", pMsg->pszDefine, rc, pMsg->pszMsgFull);
583	default:
584	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
585	return 0;
586	}
587	#else /* !IN_RING3 */
588	switch (ch)
589	{
590	case 'c':
591	case 's':
592	case 'f':
593	case 'a':
594	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%d", rc);
595	default:
596	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
597	return 0;
598	}
599	#endif /* !IN_RING3 */
600	break;
601	}
602
603	#if defined(IN_RING3)
604	/*
605	* Windows status code: %Rwc, %Rwf, %Rwa
606	*/
607	case 'w':
608	{
609	long rc = va_arg(*pArgs, long);
610	char ch = (ppszFormat)++;
611	#if defined(RT_OS_WINDOWS)
612	PCRTWINERRMSG pMsg = RTErrWinGet(rc);
613	#endif
614	switch (ch)
615	{
616	#if defined(RT_OS_WINDOWS)
617	case 'c':
618	return pfnOutput(pvArgOutput, pMsg->pszDefine, strlen(pMsg->pszDefine));
619	case 'f':
620	return pfnOutput(pvArgOutput, pMsg->pszMsgFull,strlen(pMsg->pszMsgFull));
621	case 'a':
622	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%s (0x%08X) - %s", pMsg->pszDefine, rc, pMsg->pszMsgFull);
623	#else
624	case 'c':
625	case 'f':
626	case 'a':
627	return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "0x%08X", rc);
628	#endif
629	default:
630	AssertMsgFailed(("Invalid status code format type '%.10s'!\n", pszFormatOrg));
631	return 0;
632	}
633	break;
634	}
635	#endif /* IN_RING3 */
636
637	/*
638	* Group 4, structure dumpers.
639	*/
640	case 'D':
641	{
642	/*
643	* Interpret the type.
644	*/
645	typedef enum
646	{
647	RTST_TIMESPEC
648	} RTST;
649	/** Set if it's a pointer */
650	#define RTST_FLAGS_POINTER BIT(0)
651	static const struct
652	{
653	uint8_t cch; /*< the length of the string. /
654	char sz[16-2]; /*< the part following 'R'. /
655	uint8_t cb; /*< the size of the argument. /
656	uint8_t fFlags; /*< RTST_FLAGS_ */
657	RTST enmType; /*< The structure type. /
658	}
659	/** Sorted array of types, looked up using binary search! */
660	s_aTypes[] =
661	{
662	#define STRMEM(str) sizeof(str) - 1, str
663	{ STRMEM("Dtimespec"), sizeof(PCRTTIMESPEC), RTST_FLAGS_POINTER, RTST_TIMESPEC},
664	#undef STRMEM
665	};
666	const char pszType = ppszFormat - 1;
667	int iStart = 0;
668	int iEnd = ELEMENTS(s_aTypes) - 1;
669	int i = ELEMENTS(s_aTypes) / 2;
670
671	union
672	{
673	const void *pv;
674	uint64_t u64;
675	PCRTTIMESPEC pTimeSpec;
676	} u;
677
678	AssertMsg(!chArgSize, ("Not argument size '%c' for RT types! '%.10s'\n", chArgSize, pszFormatOrg));
679
680	/*
681	* Lookup the type - binary search.
682	*/
683	for (;;)
684	{
685	int iDiff = strncmp(pszType, s_aTypes[i].sz, s_aTypes[i].cch);
686	if (!iDiff)
687	break;
688	if (iEnd == iStart)
689	{
690	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
691	return 0;
692	}
693	if (iDiff < 0)
694	iEnd = i - 1;
695	else
696	iStart = i + 1;
697	if (iEnd < iStart)
698	{
699	AssertMsgFailed(("Invalid format type '%.10s'!\n", pszFormatOrg));
700	return 0;
701	}
702	i = iStart + (iEnd - iStart) / 2;
703	}
704	*ppszFormat += s_aTypes[i].cch - 1;
705
706	/*
707	* Fetch the argument.
708	*/
709	u.u64 = 0;
710	switch (s_aTypes[i].cb)
711	{
712	case sizeof(const void *):
713	u.pv = va_arg(pArgs, const void );
714	break;
715	default:
716	AssertMsgFailed(("Invalid format error, size %d'!\n", s_aTypes[i].cb));
717	break;
718	}
719
720	/*
721	* If it's a pointer, we'll check if it's valid before going on.
722	*/
723	if ((s_aTypes[i].fFlags & RTST_FLAGS_POINTER) && !VALID_PTR(u.pv))
724	return pfnOutput(pvArgOutput, "<null>", sizeof("<null>") - 1);
725
726	/*
727	* Format the output.
728	*/
729	switch (s_aTypes[i].enmType)
730	{
731	case RTST_TIMESPEC:
732	return RTStrFormat(pfnOutput, pvArgOutput, NULL, NULL, "%lld ns", RTTimeSpecGetNano(u.pTimeSpec));
733
734	default:
735	AssertMsgFailed(("Invalid/unhandled enmType=%d\n", s_aTypes[i].enmType));
736	break;
737	}
738	break;
739	}
740
741	/*
742	* Invalid/Unknown. Bitch about it.
743	*/
744	default:
745	AssertMsgFailed(("Invalid VBox format type '%.10s'!\n", pszFormatOrg));
746	break;
747	}
748	}
749	else
750	AssertMsgFailed(("Invalid VBox format type '%.10s'!\n", pszFormatOrg));
751
752	NOREF(pszFormatOrg);
753	return 0;
754	}
755
756

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

source: vbox/trunk/src/VBox/Runtime/strformatrt.cpp@ 4968

Download in other formats: