stream.cpp@ 32235

Last change on this file since 32235 was 30111, checked in by vboxsync, 15 years ago
iprt/asm.h,: Revised the ASMAtomicPtr functions and macros. The new saves lots of unsafe (void * volatile *) casts as well as adding some type safety when using GCC (typeof rulez).
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 22.4 KB

Line
1	/* $Id: stream.cpp 30111 2010-06-09 12:14:59Z vboxsync $ */
2	/** @file
3	* IPRT - I/O Stream.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Oracle Corporation
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 (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	/*******************************************************************************
30	* Header Files *
31	*******************************************************************************/
32	#include <iprt/stream.h>
33	#include "internal/iprt.h"
34
35	#include <iprt/asm.h>
36	#include <iprt/critsect.h>
37	#include <iprt/string.h>
38	#include <iprt/assert.h>
39	#include <iprt/alloc.h>
40	#include <iprt/err.h>
41	#include <iprt/param.h>
42	#include <iprt/string.h>
43
44	#include "internal/alignmentchecks.h"
45	#include "internal/magics.h"
46
47	#include <stdio.h>
48	#include <errno.h>
49
50	#if defined(RT_OS_LINUX) /* PORTME: check for the _unlocked functions in stdio.h */
51	#define HAVE_FWRITE_UNLOCKED
52	#endif
53
54
55	/*******************************************************************************
56	* Structures and Typedefs *
57	*******************************************************************************/
58	/**
59	* File stream.
60	*/
61	typedef struct RTSTREAM
62	{
63	/** Magic value used to validate the stream. (RTSTREAM_MAGIC) */
64	uint32_t u32Magic;
65	/** File stream error. */
66	int32_t volatile i32Error;
67	/** Pointer to the LIBC file stream. */
68	FILE *pFile;
69	#ifndef HAVE_FWRITE_UNLOCKED
70	/** Critical section for serializing access to the stream. */
71	PRTCRITSECT pCritSect;
72	#endif
73	} RTSTREAM;
74
75
76	/*******************************************************************************
77	* Global Variables *
78	*******************************************************************************/
79	/** The standard input stream. */
80	static RTSTREAM g_StdIn =
81	{
82	RTSTREAM_MAGIC,
83	0,
84	stdin
85	#ifndef HAVE_FWRITE_UNLOCKED
86	, NULL
87	#endif
88	};
89
90	/** The standard error stream. */
91	static RTSTREAM g_StdErr =
92	{
93	RTSTREAM_MAGIC,
94	0,
95	stderr
96	#ifndef HAVE_FWRITE_UNLOCKED
97	, NULL
98	#endif
99	};
100
101	/** The standard output stream. */
102	static RTSTREAM g_StdOut =
103	{
104	RTSTREAM_MAGIC,
105	0,
106	stdout
107	#ifndef HAVE_FWRITE_UNLOCKED
108	, NULL
109	#endif
110	};
111
112	/** Pointer to the standard input stream. */
113	RTDATADECL(PRTSTREAM) g_pStdIn = &g_StdIn;
114
115	/** Pointer to the standard output stream. */
116	RTDATADECL(PRTSTREAM) g_pStdErr = &g_StdErr;
117
118	/** Pointer to the standard output stream. */
119	RTDATADECL(PRTSTREAM) g_pStdOut = &g_StdOut;
120
121
122	#ifndef HAVE_FWRITE_UNLOCKED
123	/**
124	* Allocates and acquires the lock for the stream.
125	*
126	* @returns IPRT status.
127	* @param pStream The stream (valid).
128	*/
129	static int rtStrmAllocLock(PRTSTREAM pStream)
130	{
131	Assert(pStream->pCritSect == NULL);
132
133	PRTCRITSECT pCritSect = (PRTCRITSECT)RTMemAlloc(sizeof(*pCritSect));
134	if (!pCritSect)
135	return VERR_NO_MEMORY;
136
137	/* The native stream lock are normally not recursive. */
138	int rc = RTCritSectInitEx(pCritSect, RTCRITSECT_FLAGS_NO_NESTING,
139	NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "RTSemSpinMutex");
140	if (RT_SUCCESS(rc))
141	{
142	rc = RTCritSectEnter(pCritSect);
143	if (RT_SUCCESS(rc))
144	{
145	if (RT_LIKELY(ASMAtomicCmpXchgPtr(&pStream->pCritSect, pCritSect, NULL)))
146	return VINF_SUCCESS;
147
148	RTCritSectLeave(pCritSect);
149	}
150	RTCritSectDelete(pCritSect);
151	}
152	RTMemFree(pCritSect);
153
154	/* Handle the lost race case... */
155	pCritSect = ASMAtomicReadPtrT(&pStream->pCritSect, PRTCRITSECT);
156	if (pCritSect)
157	return RTCritSectEnter(pCritSect);
158
159	return rc;
160	}
161	#endif /* !HAVE_FWRITE_UNLOCKED */
162
163
164	/**
165	* Locks the stream. May have to allocate the lock as well.
166	*
167	* @param pStream The stream (valid).
168	*/
169	DECLINLINE(void) rtStrmLock(PRTSTREAM pStream)
170	{
171	#ifdef HAVE_FWRITE_UNLOCKED
172	flockfile(pStream->pFile);
173	#else
174	if (RT_LIKELY(pStream->pCritSect))
175	RTCritSectEnter(pStream->pCritSect);
176	else
177	rtStrmAllocLock(pStream);
178	#endif
179	}
180
181
182	/**
183	* Unlocks the stream.
184	*
185	* @param pStream The stream (valid).
186	*/
187	DECLINLINE(void) rtStrmUnlock(PRTSTREAM pStream)
188	{
189	#ifdef HAVE_FWRITE_UNLOCKED
190	funlockfile(pStream->pFile);
191	#else
192	if (RT_LIKELY(pStream->pCritSect))
193	RTCritSectLeave(pStream->pCritSect);
194	#endif
195	}
196
197
198	/**
199	* Opens a file stream.
200	*
201	* @returns iprt status code.
202	* @param pszFilename Path to the file to open.
203	* @param pszMode The open mode. See fopen() standard.
204	* Format: <a\|r\|w>[+][b\|t]
205	* @param ppStream Where to store the opened stream.
206	*/
207	RTR3DECL(int) RTStrmOpen(const char pszFilename, const char pszMode, PRTSTREAM *ppStream)
208	{
209	/*
210	* Validate input.
211	*/
212	if (!pszMode \|\| !*pszMode)
213	{
214	AssertMsgFailed(("No pszMode!\n"));
215	return VERR_INVALID_PARAMETER;
216	}
217	if (!pszFilename)
218	{
219	AssertMsgFailed(("No pszFilename!\n"));
220	return VERR_INVALID_PARAMETER;
221	}
222	bool fOk = true;
223	switch (*pszMode)
224	{
225	case 'a':
226	case 'w':
227	case 'r':
228	switch (pszMode[1])
229	{
230	case '\0':
231	break;
232	case '+':
233	switch (pszMode[2])
234	{
235	case '\0':
236	//case 't':
237	case 'b':
238	break;
239	default:
240	fOk = false;
241	break;
242	}
243	break;
244	//case 't':
245	case 'b':
246	break;
247	default:
248	fOk = false;
249	break;
250	}
251	break;
252	default:
253	fOk = false;
254	break;
255	}
256	if (!fOk)
257	{
258	AssertMsgFailed(("Invalid pszMode='%s', '<a\|r\|w>[+][b\|t]'\n", pszMode));
259	return VINF_SUCCESS;
260	}
261
262	/*
263	* Allocate the stream handle and try open it.
264	*/
265	PRTSTREAM pStream = (PRTSTREAM)RTMemAlloc(sizeof(*pStream));
266	if (pStream)
267	{
268	pStream->u32Magic = RTSTREAM_MAGIC;
269	pStream->i32Error = VINF_SUCCESS;
270	#ifndef HAVE_FWRITE_UNLOCKED
271	pStream->pCritSect = NULL;
272	#endif /* HAVE_FWRITE_UNLOCKED */
273	pStream->pFile = fopen(pszFilename, pszMode);
274	if (pStream->pFile)
275	{
276	*ppStream = pStream;
277	return VINF_SUCCESS;
278	}
279	return RTErrConvertFromErrno(errno);
280	}
281	return VERR_NO_MEMORY;
282	}
283
284
285	/**
286	* Opens a file stream.
287	*
288	* @returns iprt status code.
289	* @param pszMode The open mode. See fopen() standard.
290	* Format: <a\|r\|w>[+][b\|t]
291	* @param ppStream Where to store the opened stream.
292	* @param pszFilenameFmt Filename path format string.
293	* @param args Arguments to the format string.
294	*/
295	RTR3DECL(int) RTStrmOpenFV(const char pszMode, PRTSTREAM ppStream, const char *pszFilenameFmt, va_list args)
296	{
297	int rc;
298	char szFilename[RTPATH_MAX];
299	size_t cch = RTStrPrintfV(szFilename, sizeof(szFilename), pszFilenameFmt, args);
300	if (cch < sizeof(szFilename))
301	rc = RTStrmOpen(szFilename, pszMode, ppStream);
302	else
303	{
304	AssertMsgFailed(("The filename is too long cch=%d\n", cch));
305	rc = VERR_FILENAME_TOO_LONG;
306	}
307	return rc;
308	}
309
310
311	/**
312	* Opens a file stream.
313	*
314	* @returns iprt status code.
315	* @param pszMode The open mode. See fopen() standard.
316	* Format: <a\|r\|w>[+][b\|t]
317	* @param ppStream Where to store the opened stream.
318	* @param pszFilenameFmt Filename path format string.
319	* @param ... Arguments to the format string.
320	*/
321	RTR3DECL(int) RTStrmOpenF(const char pszMode, PRTSTREAM ppStream, const char *pszFilenameFmt, ...)
322	{
323	va_list args;
324	va_start(args, pszFilenameFmt);
325	int rc = RTStrmOpenFV(pszMode, ppStream, pszFilenameFmt, args);
326	va_end(args);
327	return rc;
328	}
329
330
331	/**
332	* Closes the specified stream.
333	*
334	* @returns iprt status code.
335	* @param pStream The stream to close.
336	*/
337	RTR3DECL(int) RTStrmClose(PRTSTREAM pStream)
338	{
339	if (pStream && pStream->u32Magic == RTSTREAM_MAGIC)
340	{
341	if (!fclose(pStream->pFile))
342	{
343	pStream->u32Magic = 0xdeaddead;
344	pStream->pFile = NULL;
345	#ifndef HAVE_FWRITE_UNLOCKED
346	if (pStream->pCritSect)
347	{
348	RTCritSectEnter(pStream->pCritSect);
349	RTCritSectLeave(pStream->pCritSect);
350	RTCritSectDelete(pStream->pCritSect);
351	RTMemFree(pStream->pCritSect);
352	pStream->pCritSect = NULL;
353	}
354	#endif
355	RTMemFree(pStream);
356	return VINF_SUCCESS;
357	}
358
359	return RTErrConvertFromErrno(errno);
360	}
361	else
362	{
363	AssertMsgFailed(("Invalid stream!\n"));
364	return VERR_INVALID_PARAMETER;
365	}
366	}
367
368
369	/**
370	* Get the pending error of the stream.
371	*
372	* @returns iprt status code. of the stream.
373	* @param pStream The stream.
374	*/
375	RTR3DECL(int) RTStrmError(PRTSTREAM pStream)
376	{
377	int rc;
378	if (pStream && pStream->u32Magic == RTSTREAM_MAGIC)
379	rc = pStream->i32Error;
380	else
381	{
382	AssertMsgFailed(("Invalid stream!\n"));
383	rc = VERR_INVALID_PARAMETER;
384	}
385	return rc;
386	}
387
388
389	/**
390	* Clears stream error condition.
391	*
392	* All stream operations save RTStrmClose and this will fail
393	* while an error is asserted on the stream
394	*
395	* @returns iprt status code.
396	* @param pStream The stream.
397	*/
398	RTR3DECL(int) RTStrmClearError(PRTSTREAM pStream)
399	{
400	int rc;
401	if (pStream && pStream->u32Magic == RTSTREAM_MAGIC)
402	{
403	clearerr(pStream->pFile);
404	ASMAtomicXchgS32(&pStream->i32Error, VINF_SUCCESS);
405	rc = VINF_SUCCESS;
406	}
407	else
408	{
409	AssertMsgFailed(("Invalid stream!\n"));
410	rc = VERR_INVALID_PARAMETER;
411	}
412	return rc;
413	}
414
415
416	/**
417	* Rewinds the stream.
418	*
419	* Stream errors will be reset on success.
420	*
421	* @returns IPRT status code.
422	*
423	* @param pStream The stream.
424	*
425	* @remarks Not all streams are rewindable and that behavior is currently
426	* undefined for those.
427	*/
428	RTR3DECL(int) RTStrmRewind(PRTSTREAM pStream)
429	{
430	AssertPtrReturn(pStream, VERR_INVALID_HANDLE);
431	AssertReturn(pStream->u32Magic == RTSTREAM_MAGIC, VERR_INVALID_HANDLE);
432
433	int rc;
434	clearerr(pStream->pFile);
435	errno = 0;
436	if (!fseek(pStream->pFile, 0, SEEK_SET))
437	{
438	ASMAtomicXchgS32(&pStream->i32Error, VINF_SUCCESS);
439	rc = VINF_SUCCESS;
440	}
441	else
442	{
443	rc = RTErrConvertFromErrno(errno);
444	ASMAtomicXchgS32(&pStream->i32Error, rc);
445	}
446
447	return rc;
448	}
449
450
451	/**
452	* Reads from a file stream.
453	*
454	* @returns iprt status code.
455	* @param pStream The stream.
456	* @param pvBuf Where to put the read bits.
457	* Must be cbRead bytes or more.
458	* @param cbRead Number of bytes to read.
459	* @param pcbRead Where to store the number of bytes actually read.
460	* If NULL cbRead bytes are read or an error is returned.
461	*/
462	RTR3DECL(int) RTStrmReadEx(PRTSTREAM pStream, void pvBuf, size_t cbRead, size_t pcbRead)
463	{
464	int rc;
465	if (pStream && pStream->u32Magic == RTSTREAM_MAGIC)
466	{
467	rc = pStream->i32Error;
468	if (RT_SUCCESS(rc))
469	{
470	if (pcbRead)
471	{
472	/*
473	* Can do with a partial read.
474	*/
475	*pcbRead = fread(pvBuf, 1, cbRead, pStream->pFile);
476	if ( *pcbRead == cbRead
477	\|\| !ferror(pStream->pFile))
478	return VINF_SUCCESS;
479	if (feof(pStream->pFile))
480	{
481	if (*pcbRead)
482	return VINF_EOF;
483	rc = VERR_EOF;
484	}
485	else if (ferror(pStream->pFile))
486	rc = VERR_READ_ERROR;
487	else
488	{
489	AssertMsgFailed(("This shouldn't happen\n"));
490	rc = VERR_INTERNAL_ERROR;
491	}
492	}
493	else
494	{
495	/*
496	* Must read it all!
497	*/
498	if (fread(pvBuf, cbRead, 1, pStream->pFile) == 1)
499	return VINF_SUCCESS;
500
501	/* possible error/eof. */
502	if (feof(pStream->pFile))
503	rc = VERR_EOF;
504	else if (ferror(pStream->pFile))
505	rc = VERR_READ_ERROR;
506	else
507	{
508	AssertMsgFailed(("This shouldn't happen\n"));
509	rc = VERR_INTERNAL_ERROR;
510	}
511	}
512	ASMAtomicXchgS32(&pStream->i32Error, rc);
513	}
514	}
515	else
516	{
517	AssertMsgFailed(("Invalid stream!\n"));
518	rc = VERR_INVALID_PARAMETER;
519	}
520	return rc;
521	}
522
523
524	/**
525	* Writes to a file stream.
526	*
527	* @returns iprt status code.
528	* @param pStream The stream.
529	* @param pvBuf Where to get the bits to write from.
530	* @param cbWrite Number of bytes to write.
531	* @param pcbWritten Where to store the number of bytes actually written.
532	* If NULL cbWrite bytes are written or an error is returned.
533	*/
534	RTR3DECL(int) RTStrmWriteEx(PRTSTREAM pStream, const void pvBuf, size_t cbWrite, size_t pcbWritten)
535	{
536	int rc;
537	if (pStream && pStream->u32Magic == RTSTREAM_MAGIC)
538	{
539	rc = pStream->i32Error;
540	if (RT_SUCCESS(rc))
541	{
542	if (pcbWritten)
543	{
544	IPRT_ALIGNMENT_CHECKS_DISABLE(); /* glibc / mempcpy again */
545	*pcbWritten = fwrite(pvBuf, 1, cbWrite, pStream->pFile);
546	IPRT_ALIGNMENT_CHECKS_ENABLE();
547	if ( *pcbWritten == cbWrite
548	\|\| !ferror(pStream->pFile))
549	return VINF_SUCCESS;
550	rc = VERR_WRITE_ERROR;
551	}
552	else
553	{
554	/*
555	* Must write it all!
556	*/
557	IPRT_ALIGNMENT_CHECKS_DISABLE(); /* glibc / mempcpy again */
558	size_t cbWritten = fwrite(pvBuf, cbWrite, 1, pStream->pFile);
559	IPRT_ALIGNMENT_CHECKS_ENABLE();
560	if (cbWritten == 1)
561	return VINF_SUCCESS;
562	if (!ferror(pStream->pFile))
563	return VINF_SUCCESS; /* WEIRD! But anyway... */
564
565	rc = VERR_WRITE_ERROR;
566	}
567	ASMAtomicXchgS32(&pStream->i32Error, rc);
568	}
569	}
570	else
571	{
572	AssertMsgFailed(("Invalid stream!\n"));
573	rc = VERR_INVALID_PARAMETER;
574	}
575	return rc;
576	}
577
578
579	/**
580	* Reads a character from a file stream.
581	*
582	* @returns The char as an unsigned char cast to int.
583	* @returns -1 on failure.
584	* @param pStream The stream.
585	*/
586	RTR3DECL(int) RTStrmGetCh(PRTSTREAM pStream)
587	{
588	unsigned char ch;
589	int rc = RTStrmReadEx(pStream, &ch, 1, NULL);
590	if (RT_SUCCESS(rc))
591	return ch;
592	return -1;
593	}
594
595
596	/**
597	* Writes a character to a file stream.
598	*
599	* @returns iprt status code.
600	* @param pStream The stream.
601	* @param ch The char to write.
602	*/
603	RTR3DECL(int) RTStrmPutCh(PRTSTREAM pStream, int ch)
604	{
605	return RTStrmWriteEx(pStream, &ch, 1, NULL);
606	}
607
608
609	/**
610	* Writes a string to a file stream.
611	*
612	* @returns iprt status code.
613	* @param pStream The stream.
614	* @param pszString The string to write.
615	* No newlines or anything is appended or prepended.
616	* The terminating '\\0' is not written, of course.
617	*/
618	RTR3DECL(int) RTStrmPutStr(PRTSTREAM pStream, const char *pszString)
619	{
620	size_t cch = strlen(pszString);
621	return RTStrmWriteEx(pStream, pszString, cch, NULL);
622	}
623
624
625	/**
626	* Reads a line from a file stream.
627	* A line ends with a '\\n', '\\0' or the end of the file.
628	*
629	* @returns iprt status code.
630	* @returns VINF_BUFFER_OVERFLOW if the buffer wasn't big enough to read an entire line.
631	* @param pStream The stream.
632	* @param pszString Where to store the line.
633	* The line will NOT contain any '\\n'.
634	* @param cchString The size of the string buffer.
635	*/
636	RTR3DECL(int) RTStrmGetLine(PRTSTREAM pStream, char *pszString, size_t cchString)
637	{
638	int rc;
639	if (pStream && pStream->u32Magic == RTSTREAM_MAGIC)
640	{
641	if (pszString && cchString > 1)
642	{
643	rc = pStream->i32Error;
644	if (RT_SUCCESS(rc))
645	{
646	cchString--; /* save space for the terminator. */
647	rtStrmLock(pStream);
648	for (;;)
649	{
650	#ifdef HAVE_FWRITE_UNLOCKED /** @todo darwin + freebsd(?) has fgetc_unlocked but not fwrite_unlocked, optimize... */
651	int ch = fgetc_unlocked(pStream->pFile);
652	#else
653	int ch = fgetc(pStream->pFile);
654	#endif
655	if (ch == EOF)
656	{
657	#ifdef HAVE_FWRITE_UNLOCKED
658	if (feof_unlocked(pStream->pFile))
659	#else
660	if (feof(pStream->pFile))
661	#endif
662	{
663	rc = VERR_EOF;
664	break;
665	}
666	#ifdef HAVE_FWRITE_UNLOCKED
667	if (ferror_unlocked(pStream->pFile))
668	#else
669	if (ferror(pStream->pFile))
670	#endif
671	rc = VERR_READ_ERROR;
672	else
673	{
674	AssertMsgFailed(("This shouldn't happen\n"));
675	rc = VERR_INTERNAL_ERROR;
676	}
677	break;
678	}
679	if (ch == '\0' \|\| ch == '\n' \|\| ch == '\r')
680	break;
681	*pszString++ = ch;
682	if (--cchString <= 0)
683	{
684	rc = VINF_BUFFER_OVERFLOW;
685	break;
686	}
687	}
688	rtStrmUnlock(pStream);
689
690	*pszString = '\0';
691	if (RT_FAILURE(rc))
692	ASMAtomicXchgS32(&pStream->i32Error, rc);
693	}
694	}
695	else
696	{
697	AssertMsgFailed(("no buffer or too small buffer!\n"));
698	rc = VERR_INVALID_PARAMETER;
699	}
700	}
701	else
702	{
703	AssertMsgFailed(("Invalid stream!\n"));
704	rc = VERR_INVALID_PARAMETER;
705	}
706	return rc;
707	}
708
709
710	/**
711	* Flushes a stream.
712	*
713	* @returns iprt status code.
714	* @param pStream The stream to flush.
715	*/
716	RTR3DECL(int) RTStrmFlush(PRTSTREAM pStream)
717	{
718	if (!fflush(pStream->pFile))
719	return VINF_SUCCESS;
720	return RTErrConvertFromErrno(errno);
721	}
722
723
724	/**
725	* Output callback.
726	*
727	* @returns number of bytes written.
728	* @param pvArg User argument.
729	* @param pachChars Pointer to an array of utf-8 characters.
730	* @param cchChars Number of bytes in the character array pointed to by pachChars.
731	*/
732	static DECLCALLBACK(size_t) rtstrmOutput(void pvArg, const char pachChars, size_t cchChars)
733	{
734	if (cchChars)
735	{
736	PRTSTREAM pStream = (PRTSTREAM)pvArg;
737	int rc = pStream->i32Error;
738	if (RT_SUCCESS(rc))
739	{
740	IPRT_ALIGNMENT_CHECKS_DISABLE(); /* glibc / mempcpy again */
741	#ifdef HAVE_FWRITE_UNLOCKED
742	if (fwrite_unlocked(pachChars, cchChars, 1, pStream->pFile) != 1)
743	#else
744	if (fwrite(pachChars, cchChars, 1, pStream->pFile) != 1)
745	#endif
746	ASMAtomicXchgS32(&pStream->i32Error, VERR_WRITE_ERROR);
747	IPRT_ALIGNMENT_CHECKS_ENABLE();
748	}
749	}
750	/* else: ignore termination call. */
751	return cchChars;
752	}
753
754
755	/**
756	* Prints a formatted string to the specified stream.
757	*
758	* @returns Number of bytes printed.
759	* @param pStream The stream to print to.
760	* @param pszFormat IPRT format string.
761	* @param args Arguments specified by pszFormat.
762	*/
763	RTR3DECL(int) RTStrmPrintfV(PRTSTREAM pStream, const char *pszFormat, va_list args)
764	{
765	int rc;
766	if (pStream && pStream->u32Magic == RTSTREAM_MAGIC)
767	{
768	rc = pStream->i32Error;
769	if (RT_SUCCESS(rc))
770	{
771	rtStrmLock(pStream);
772	rc = (int)RTStrFormatV(rtstrmOutput, pStream, NULL, NULL, pszFormat, args);
773	rtStrmUnlock(pStream);
774	Assert(rc >= 0);
775	}
776	else
777	rc = -1;
778	}
779	else
780	{
781	AssertMsgFailed(("Invalid stream!\n"));
782	rc = -1;
783	}
784	return rc;
785	}
786
787
788	/**
789	* Prints a formatted string to the specified stream.
790	*
791	* @returns Number of bytes printed.
792	* @param pStream The stream to print to.
793	* @param pszFormat IPRT format string.
794	* @param ... Arguments specified by pszFormat.
795	*/
796	RTR3DECL(int) RTStrmPrintf(PRTSTREAM pStream, const char *pszFormat, ...)
797	{
798	va_list args;
799	va_start(args, pszFormat);
800	int rc = RTStrmPrintfV(pStream, pszFormat, args);
801	va_end(args);
802	return rc;
803	}
804
805
806	/**
807	* Prints a formatted string to the standard output stream (g_pStdOut).
808	*
809	* @returns Number of bytes printed.
810	* @param pszFormat IPRT format string.
811	* @param args Arguments specified by pszFormat.
812	*/
813	RTR3DECL(int) RTPrintfV(const char *pszFormat, va_list args)
814	{
815	return RTStrmPrintfV(g_pStdOut, pszFormat, args);
816	}
817
818
819	/**
820	* Prints a formatted string to the standard output stream (g_pStdOut).
821	*
822	* @returns Number of bytes printed.
823	* @param pszFormat IPRT format string.
824	* @param ... Arguments specified by pszFormat.
825	*/
826	RTR3DECL(int) RTPrintf(const char *pszFormat, ...)
827	{
828	va_list args;
829	va_start(args, pszFormat);
830	int rc = RTStrmPrintfV(g_pStdOut, pszFormat, args);
831	va_end(args);
832	return rc;
833	}
834

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

source: vbox/trunk/src/VBox/Runtime/r3/stream.cpp@ 32235

Download in other formats: