scmstream.cpp@ 84250

Last change on this file since 84250 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 41.8 KB

Line
1	/* $Id: scmstream.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* IPRT Testcase / Tool - Source Code Massager Stream Code.
4	*/
5
6	/*
7	* Copyright (C) 2010-2020 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
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <iprt/assert.h>
23	#include <iprt/ctype.h>
24	#include <iprt/err.h>
25	#include <iprt/file.h>
26	#include <iprt/handle.h>
27	#include <iprt/mem.h>
28	#include <iprt/pipe.h>
29	#include <iprt/string.h>
30
31	#include "scmstream.h"
32
33
34	/**
35	* Initializes the stream structure.
36	*
37	* @param pStream The stream structure.
38	* @param fWriteOrRead The value of the fWriteOrRead stream member.
39	*/
40	static void scmStreamInitInternal(PSCMSTREAM pStream, bool fWriteOrRead)
41	{
42	pStream->pch = NULL;
43	pStream->off = 0;
44	pStream->cb = 0;
45	pStream->cbAllocated = 0;
46
47	pStream->paLines = NULL;
48	pStream->iLine = 0;
49	pStream->cLines = 0;
50	pStream->cLinesAllocated = 0;
51
52	pStream->fWriteOrRead = fWriteOrRead;
53	pStream->fFileMemory = false;
54	pStream->fFullyLineated = false;
55
56	pStream->rc = VINF_SUCCESS;
57	}
58
59	/**
60	* Initialize an input stream.
61	*
62	* @returns IPRT status code.
63	* @param pStream The stream to initialize.
64	* @param pszFilename The file to take the stream content from.
65	*/
66	int ScmStreamInitForReading(PSCMSTREAM pStream, const char *pszFilename)
67	{
68	scmStreamInitInternal(pStream, false /fWriteOrRead/);
69
70	void *pvFile;
71	size_t cbFile;
72	int rc = pStream->rc = RTFileReadAll(pszFilename, &pvFile, &cbFile);
73	if (RT_SUCCESS(rc))
74	{
75	pStream->pch = (char *)pvFile;
76	pStream->cb = cbFile;
77	pStream->cbAllocated = cbFile;
78	pStream->fFileMemory = true;
79	}
80	return rc;
81	}
82
83	/**
84	* Initialize an output stream.
85	*
86	* @returns IPRT status code
87	* @param pStream The stream to initialize.
88	* @param pRelatedStream Pointer to a related stream. NULL is fine.
89	*/
90	int ScmStreamInitForWriting(PSCMSTREAM pStream, PCSCMSTREAM pRelatedStream)
91	{
92	scmStreamInitInternal(pStream, true /fWriteOrRead/);
93
94	/* allocate stuff */
95	size_t cbEstimate = !pRelatedStream ? _64K
96	: pRelatedStream->cb > 0 ? pRelatedStream->cb + pRelatedStream->cb / 10 : 64;
97	cbEstimate = RT_ALIGN(cbEstimate, _4K);
98	pStream->pch = (char *)RTMemAlloc(cbEstimate);
99	if (pStream->pch)
100	{
101	size_t cLinesEstimate = pRelatedStream && pRelatedStream->fFullyLineated
102	? pRelatedStream->cLines + pRelatedStream->cLines / 10
103	: cbEstimate / 24;
104	cLinesEstimate = RT_ALIGN(cLinesEstimate, 512);
105	if (cLinesEstimate == 0)
106	cLinesEstimate = 16;
107	pStream->paLines = (PSCMSTREAMLINE)RTMemAlloc(cLinesEstimate * sizeof(SCMSTREAMLINE));
108	if (pStream->paLines)
109	{
110	pStream->paLines[0].off = 0;
111	pStream->paLines[0].cch = 0;
112	pStream->paLines[0].enmEol = SCMEOL_NONE;
113	pStream->cbAllocated = cbEstimate;
114	pStream->cLinesAllocated = cLinesEstimate;
115	return VINF_SUCCESS;
116	}
117
118	RTMemFree(pStream->pch);
119	pStream->pch = NULL;
120	}
121	return pStream->rc = VERR_NO_MEMORY;
122	}
123
124	/**
125	* Frees the resources associated with the stream.
126	*
127	* Nothing is happens to whatever the stream was initialized from or dumped to.
128	*
129	* @param pStream The stream to delete.
130	*/
131	void ScmStreamDelete(PSCMSTREAM pStream)
132	{
133	if (pStream->pch)
134	{
135	if (pStream->fFileMemory)
136	RTFileReadAllFree(pStream->pch, pStream->cbAllocated);
137	else
138	RTMemFree(pStream->pch);
139	pStream->pch = NULL;
140	}
141	pStream->cbAllocated = 0;
142
143	if (pStream->paLines)
144	{
145	RTMemFree(pStream->paLines);
146	pStream->paLines = NULL;
147	}
148	pStream->cLinesAllocated = 0;
149	}
150
151	/**
152	* Get the stream status code.
153	*
154	* @returns IPRT status code.
155	* @param pStream The stream.
156	*/
157	int ScmStreamGetStatus(PCSCMSTREAM pStream)
158	{
159	return pStream->rc;
160	}
161
162	/**
163	* Grows the buffer of a write stream.
164	*
165	* @returns IPRT status code.
166	* @param pStream The stream. Must be in write mode.
167	* @param cbAppending The minimum number of bytes to grow the buffer
168	* with.
169	*/
170	static int scmStreamGrowBuffer(PSCMSTREAM pStream, size_t cbAppending)
171	{
172	size_t cbAllocated = pStream->cbAllocated;
173	cbAllocated += RT_MAX(0x1000 + cbAppending, cbAllocated);
174	cbAllocated = RT_ALIGN(cbAllocated, 0x1000);
175	void *pvNew;
176	if (!pStream->fFileMemory)
177	{
178	pvNew = RTMemRealloc(pStream->pch, cbAllocated);
179	if (!pvNew)
180	return pStream->rc = VERR_NO_MEMORY;
181	}
182	else
183	{
184	pvNew = RTMemDupEx(pStream->pch, pStream->off, cbAllocated - pStream->off);
185	if (!pvNew)
186	return pStream->rc = VERR_NO_MEMORY;
187	RTFileReadAllFree(pStream->pch, pStream->cbAllocated);
188	pStream->fFileMemory = false;
189	}
190	pStream->pch = (char *)pvNew;
191	pStream->cbAllocated = cbAllocated;
192
193	return VINF_SUCCESS;
194	}
195
196	/**
197	* Grows the line array of a stream.
198	*
199	* @returns IPRT status code.
200	* @param pStream The stream.
201	* @param iMinLine Minimum line number.
202	*/
203	static int scmStreamGrowLines(PSCMSTREAM pStream, size_t iMinLine)
204	{
205	size_t cLinesAllocated = pStream->cLinesAllocated;
206	cLinesAllocated += RT_MAX(512 + iMinLine, cLinesAllocated);
207	cLinesAllocated = RT_ALIGN(cLinesAllocated, 512);
208	void pvNew = RTMemRealloc(pStream->paLines, cLinesAllocated sizeof(SCMSTREAMLINE));
209	if (!pvNew)
210	return pStream->rc = VERR_NO_MEMORY;
211
212	pStream->paLines = (PSCMSTREAMLINE)pvNew;
213	pStream->cLinesAllocated = cLinesAllocated;
214	return VINF_SUCCESS;
215	}
216
217	/**
218	* Rewinds the stream and sets the mode to read.
219	*
220	* @param pStream The stream.
221	*/
222	void ScmStreamRewindForReading(PSCMSTREAM pStream)
223	{
224	pStream->off = 0;
225	pStream->iLine = 0;
226	pStream->fWriteOrRead = false;
227	pStream->rc = VINF_SUCCESS;
228	}
229
230	/**
231	* Rewinds the stream and sets the mode to write.
232	*
233	* @param pStream The stream.
234	*/
235	void ScmStreamRewindForWriting(PSCMSTREAM pStream)
236	{
237	pStream->off = 0;
238	pStream->iLine = 0;
239	pStream->cLines = 0;
240	pStream->fWriteOrRead = true;
241	pStream->fFullyLineated = true;
242	pStream->rc = VINF_SUCCESS;
243
244	/* Initialize the first line with a zero length so ScmStreamWrite won't misbehave. */
245	if (pStream->cLinesAllocated == 0)
246	scmStreamGrowLines(pStream, 1);
247	if (pStream->cLinesAllocated > 0)
248	{
249	pStream->paLines[0].off = 0;
250	pStream->paLines[0].cch = 0;
251	pStream->paLines[0].enmEol = SCMEOL_NONE;
252	}
253	}
254
255	/**
256	* Checks if it's a text stream.
257	*
258	* Not 100% proof.
259	*
260	* @returns true if it probably is a text file, false if not.
261	* @param pStream The stream. Write or read, doesn't matter.
262	*/
263	bool ScmStreamIsText(PSCMSTREAM pStream)
264	{
265	if (RTStrEnd(pStream->pch, pStream->cb))
266	return false;
267	if (!pStream->cb)
268	return true;
269	return true;
270	}
271
272	/**
273	* Performs an integrity check of the stream.
274	*
275	* @returns IPRT status code.
276	* @param pStream The stream.
277	*/
278	int ScmStreamCheckItegrity(PSCMSTREAM pStream)
279	{
280	/*
281	* Perform sanity checks.
282	*/
283	size_t const cbFile = pStream->cb;
284	for (size_t iLine = 0; iLine < pStream->cLines; iLine++)
285	{
286	size_t offEol = pStream->paLines[iLine].off + pStream->paLines[iLine].cch;
287	AssertReturn(offEol + pStream->paLines[iLine].enmEol <= cbFile, VERR_INTERNAL_ERROR_2);
288	switch (pStream->paLines[iLine].enmEol)
289	{
290	case SCMEOL_LF:
291	AssertReturn(pStream->pch[offEol] == '\n', VERR_INTERNAL_ERROR_3);
292	break;
293	case SCMEOL_CRLF:
294	AssertReturn(pStream->pch[offEol] == '\r', VERR_INTERNAL_ERROR_3);
295	AssertReturn(pStream->pch[offEol + 1] == '\n', VERR_INTERNAL_ERROR_3);
296	break;
297	case SCMEOL_NONE:
298	AssertReturn(iLine + 1 >= pStream->cLines, VERR_INTERNAL_ERROR_4);
299	break;
300	default:
301	AssertReturn(iLine + 1 >= pStream->cLines, VERR_INTERNAL_ERROR_5);
302	}
303	}
304	return VINF_SUCCESS;
305	}
306
307	/**
308	* Writes the stream to a file.
309	*
310	* @returns IPRT status code
311	* @param pStream The stream.
312	* @param pszFilenameFmt The filename format string.
313	* @param ... Format arguments.
314	*/
315	int ScmStreamWriteToFile(PSCMSTREAM pStream, const char *pszFilenameFmt, ...)
316	{
317	int rc;
318
319	#ifdef RT_STRICT
320	/*
321	* Check that what we're going to write makes sense first.
322	*/
323	rc = ScmStreamCheckItegrity(pStream);
324	if (RT_FAILURE(rc))
325	return rc;
326	#endif
327
328	/*
329	* Do the actual writing.
330	*/
331	RTFILE hFile;
332	va_list va;
333	va_start(va, pszFilenameFmt);
334	rc = RTFileOpenV(&hFile, RTFILE_O_WRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_WRITE, pszFilenameFmt, va);
335	if (RT_SUCCESS(rc))
336	{
337	rc = RTFileWrite(hFile, pStream->pch, pStream->cb, NULL);
338	RTFileClose(hFile);
339	}
340	va_end(va);
341	return rc;
342	}
343
344	/**
345	* Writes the stream to standard output.
346	*
347	* @returns IPRT status code
348	* @param pStream The stream.
349	*/
350	int ScmStreamWriteToStdOut(PSCMSTREAM pStream)
351	{
352	int rc;
353
354	#ifdef RT_STRICT
355	/*
356	* Check that what we're going to write makes sense first.
357	*/
358	rc = ScmStreamCheckItegrity(pStream);
359	if (RT_FAILURE(rc))
360	return rc;
361	#endif
362
363	/*
364	* Do the actual writing.
365	*/
366	RTHANDLE h;
367	rc = RTHandleGetStandard(RTHANDLESTD_OUTPUT, &h);
368	if (RT_SUCCESS(rc))
369	{
370	switch (h.enmType)
371	{
372	case RTHANDLETYPE_FILE:
373	rc = RTFileWrite(h.u.hFile, pStream->pch, pStream->cb, NULL);
374	break;
375	case RTHANDLETYPE_PIPE:
376	rc = RTPipeWriteBlocking(h.u.hPipe, pStream->pch, pStream->cb, NULL);
377	break;
378	default:
379	rc = VERR_INVALID_HANDLE;
380	break;
381	}
382	}
383	return rc;
384	}
385
386	/**
387	* Worker for ScmStreamGetLine that builds the line number index while parsing
388	* the stream.
389	*
390	* @returns Same as SCMStreamGetLine.
391	* @param pStream The stream. Must be in read mode.
392	* @param pcchLine Where to return the line length.
393	* @param penmEol Where to return the kind of end of line marker.
394	*/
395	static const char scmStreamGetLineInternal(PSCMSTREAM pStream, size_t pcchLine, PSCMEOL penmEol)
396	{
397	AssertReturn(!pStream->fWriteOrRead, NULL);
398	if (RT_FAILURE(pStream->rc))
399	return NULL;
400
401	size_t off = pStream->off;
402	size_t cb = pStream->cb;
403	if (RT_UNLIKELY(off >= cb))
404	{
405	pStream->fFullyLineated = true;
406	return NULL;
407	}
408
409	size_t iLine = pStream->iLine;
410	if (RT_UNLIKELY(iLine >= pStream->cLinesAllocated))
411	{
412	int rc = scmStreamGrowLines(pStream, iLine);
413	if (RT_FAILURE(rc))
414	return NULL;
415	}
416	pStream->paLines[iLine].off = off;
417
418	cb -= off;
419	const char *pchRet = &pStream->pch[off];
420	const char pch = (const char )memchr(pchRet, '\n', cb);
421	if (RT_LIKELY(pch))
422	{
423	cb = pch - pchRet;
424	pStream->off = off + cb + 1;
425	if ( cb < 1
426	\|\| pch[-1] != '\r')
427	pStream->paLines[iLine].enmEol = *penmEol = SCMEOL_LF;
428	else
429	{
430	pStream->paLines[iLine].enmEol = *penmEol = SCMEOL_CRLF;
431	cb--;
432	}
433	}
434	else
435	{
436	pStream->off = off + cb;
437	pStream->paLines[iLine].enmEol = *penmEol = SCMEOL_NONE;
438	}
439	*pcchLine = cb;
440	pStream->paLines[iLine].cch = cb;
441	pStream->cLines = pStream->iLine = ++iLine;
442
443	return pchRet;
444	}
445
446	/**
447	* Internal worker that delineates a stream.
448	*
449	* @returns IPRT status code.
450	* @param pStream The stream. Caller must check that it is in
451	* read mode.
452	*/
453	static int scmStreamLineate(PSCMSTREAM pStream)
454	{
455	/* Save the stream position. */
456	size_t const offSaved = pStream->off;
457	size_t const iLineSaved = pStream->iLine;
458
459	/* Get each line. */
460	size_t cchLine;
461	SCMEOL enmEol;
462	while (scmStreamGetLineInternal(pStream, &cchLine, &enmEol))
463	/* nothing */;
464	Assert(RT_FAILURE(pStream->rc) \|\| pStream->fFullyLineated);
465
466	/* Restore the position */
467	pStream->off = offSaved;
468	pStream->iLine = iLineSaved;
469
470	return pStream->rc;
471	}
472
473	/**
474	* Get the current stream position as an byte offset.
475	*
476	* @returns The current byte offset
477	* @param pStream The stream.
478	*/
479	size_t ScmStreamTell(PSCMSTREAM pStream)
480	{
481	return pStream->off;
482	}
483
484	/**
485	* Get the current stream position as a line number.
486	*
487	* @returns The current line (0-based).
488	* @param pStream The stream.
489	*/
490	size_t ScmStreamTellLine(PSCMSTREAM pStream)
491	{
492	return pStream->iLine;
493	}
494
495
496	/**
497	* Gets the stream offset of a given line.
498	*
499	* @returns The offset of the line, or the stream size if the line number is too
500	* high.
501	* @param pStream The stream. Must be in read mode.
502	* @param iLine The line we're asking about.
503	*/
504	size_t ScmStreamTellOffsetOfLine(PSCMSTREAM pStream, size_t iLine)
505	{
506	AssertReturn(!pStream->fWriteOrRead, pStream->cb);
507	if (!pStream->fFullyLineated)
508	{
509	int rc = scmStreamLineate(pStream);
510	AssertRCReturn(rc, pStream->cb);
511	}
512	if (iLine >= pStream->cLines)
513	return pStream->cb;
514	return pStream->paLines[iLine].off;
515	}
516
517
518	/**
519	* Get the current stream size in bytes.
520	*
521	* @returns Count of bytes.
522	* @param pStream The stream.
523	*/
524	size_t ScmStreamSize(PSCMSTREAM pStream)
525	{
526	return pStream->cb;
527	}
528
529	/**
530	* Gets the number of lines in the stream.
531	*
532	* @returns The number of lines.
533	* @param pStream The stream.
534	*/
535	size_t ScmStreamCountLines(PSCMSTREAM pStream)
536	{
537	if (!pStream->fFullyLineated)
538	scmStreamLineate(pStream);
539	return pStream->cLines;
540	}
541
542	/**
543	* Seeks to a given byte offset in the stream.
544	*
545	* @returns IPRT status code.
546	* @retval VERR_SEEK if the new stream position is the middle of an EOL marker.
547	* This is a temporary restriction.
548	*
549	* @param pStream The stream. Must be in read mode.
550	* @param offAbsolute The offset to seek to. If this is beyond the
551	* end of the stream, the position is set to the
552	* end.
553	*/
554	int ScmStreamSeekAbsolute(PSCMSTREAM pStream, size_t offAbsolute)
555	{
556	AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
557	if (RT_FAILURE(pStream->rc))
558	return pStream->rc;
559
560	/* Must be fully delineated. (lazy bird) */
561	if (RT_UNLIKELY(!pStream->fFullyLineated))
562	{
563	int rc = scmStreamLineate(pStream);
564	if (RT_FAILURE(rc))
565	return rc;
566	}
567
568	/* Ok, do the job. */
569	if (offAbsolute < pStream->cb)
570	{
571	/** @todo Should do a binary search here, but I'm too darn lazy tonight. */
572	pStream->off = ~(size_t)0;
573	for (size_t i = 0; i < pStream->cLines; i++)
574	{
575	if (offAbsolute < pStream->paLines[i].off + pStream->paLines[i].cch + pStream->paLines[i].enmEol)
576	{
577	pStream->off = offAbsolute;
578	pStream->iLine = i;
579	if (offAbsolute > pStream->paLines[i].off + pStream->paLines[i].cch)
580	return pStream->rc = VERR_SEEK;
581	break;
582	}
583	}
584	AssertReturn(pStream->off != ~(size_t)0, pStream->rc = VERR_INTERNAL_ERROR_3);
585	}
586	else
587	{
588	pStream->off = pStream->cb;
589	pStream->iLine = pStream->cLines;
590	}
591	return VINF_SUCCESS;
592	}
593
594
595	/**
596	* Seeks a number of bytes relative to the current stream position.
597	*
598	* @returns IPRT status code.
599	* @retval VERR_SEEK if the new stream position is the middle of an EOL marker.
600	* This is a temporary restriction.
601	*
602	* @param pStream The stream. Must be in read mode.
603	* @param offRelative The offset to seek to. A negative offset
604	* rewinds and positive one fast forwards the
605	* stream. Will quietly stop at the beginning and
606	* end of the stream.
607	*/
608	int ScmStreamSeekRelative(PSCMSTREAM pStream, ssize_t offRelative)
609	{
610	size_t offAbsolute;
611	if (offRelative >= 0)
612	offAbsolute = pStream->off + offRelative;
613	else if ((size_t)-offRelative <= pStream->off)
614	offAbsolute = pStream->off + offRelative;
615	else
616	offAbsolute = 0;
617	return ScmStreamSeekAbsolute(pStream, offAbsolute);
618	}
619
620	/**
621	* Seeks to a given line in the stream.
622	*
623	* @returns IPRT status code.
624	*
625	* @param pStream The stream. Must be in read mode.
626	* @param iLine The line to seek to. If this is beyond the end
627	* of the stream, the position is set to the end.
628	*/
629	int ScmStreamSeekByLine(PSCMSTREAM pStream, size_t iLine)
630	{
631	if (RT_FAILURE(pStream->rc))
632	return pStream->rc;
633
634	/* Must be fully delineated. (lazy bird) */
635	if (RT_UNLIKELY(!pStream->fFullyLineated))
636	{
637	AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
638	int rc = scmStreamLineate(pStream);
639	if (RT_FAILURE(rc))
640	return rc;
641	}
642
643	/* Ok, do the job. */
644	if (iLine < pStream->cLines)
645	{
646	pStream->iLine = iLine;
647	pStream->off = pStream->paLines[iLine].off;
648	if (pStream->fWriteOrRead)
649	{
650	pStream->cb = pStream->paLines[iLine].off;
651	pStream->cLines = iLine;
652	pStream->paLines[iLine].cch = 0;
653	pStream->paLines[iLine].enmEol = SCMEOL_NONE;
654	}
655	}
656	else
657	{
658	AssertReturn(!pStream->fWriteOrRead, VERR_ACCESS_DENIED);
659	pStream->off = pStream->cb;
660	pStream->iLine = pStream->cLines;
661	}
662	return VINF_SUCCESS;
663	}
664
665	/**
666	* Checks if the stream position is at the start of a line.
667	*
668	* @returns @c true if at the start, @c false if not.
669	* @param pStream The stream.
670	*/
671	bool ScmStreamIsAtStartOfLine(PSCMSTREAM pStream)
672	{
673	if ( !pStream->fFullyLineated
674	&& !pStream->fWriteOrRead)
675	{
676	int rc = scmStreamLineate(pStream);
677	if (RT_FAILURE(rc))
678	return false;
679	}
680	return pStream->off == pStream->paLines[pStream->iLine].off;
681	}
682
683	/**
684	* Worker for ScmStreamGetLineByNo and ScmStreamGetLine.
685	*
686	* Works on a fully lineated stream.
687	*
688	* @returns Pointer to the first character in the line, not NULL terminated.
689	* NULL if the end of the stream has been reached or some problem
690	* occurred.
691	*
692	* @param pStream The stream. Must be in read mode.
693	* @param iLine The line to get (0-based).
694	* @param pcchLine The length.
695	* @param penmEol Where to return the end of line type indicator.
696	*/
697	DECLINLINE(const char ) scmStreamGetLineByNoCommon(PSCMSTREAM pStream, size_t iLine, size_t pcchLine, PSCMEOL penmEol)
698	{
699	Assert(!pStream->fWriteOrRead);
700	Assert(pStream->fFullyLineated);
701
702	/* Check stream status. */
703	if (RT_SUCCESS(pStream->rc))
704	{
705	/* Not at the end of the stream yet? */
706	if (RT_LIKELY(iLine < pStream->cLines))
707	{
708	/* Get the data. */
709	const char *pchRet = &pStream->pch[pStream->paLines[iLine].off];
710	*pcchLine = pStream->paLines[iLine].cch;
711	*penmEol = pStream->paLines[iLine].enmEol;
712
713	/* update the stream position. */
714	pStream->off = pStream->paLines[iLine].off + pStream->paLines[iLine].cch + pStream->paLines[iLine].enmEol;
715	pStream->iLine = iLine + 1;
716	return pchRet;
717	}
718	pStream->off = pStream->cb;
719	pStream->iLine = pStream->cLines;
720	}
721	*pcchLine = 0;
722	*penmEol = SCMEOL_NONE;
723	return NULL;
724	}
725
726
727	/**
728	* Get a numbered line from the stream (changes the position).
729	*
730	* A line is always delimited by a LF character or the end of the stream. The
731	* delimiter is not included in returned line length, but instead returned via
732	* the @a penmEol indicator.
733	*
734	* @returns Pointer to the first character in the line, not NULL terminated.
735	* NULL if the end of the stream has been reached or some problem
736	* occurred (pcchLine set to zero and penmEol to SCMEOL_NONE).
737	*
738	* @param pStream The stream. Must be in read mode.
739	* @param iLine The line to get (0-based).
740	* @param pcchLine The length.
741	* @param penmEol Where to return the end of line type indicator.
742	*/
743	const char ScmStreamGetLineByNo(PSCMSTREAM pStream, size_t iLine, size_t pcchLine, PSCMEOL penmEol)
744	{
745	AssertReturn(!pStream->fWriteOrRead, NULL);
746
747	/* Make sure it's fully delineated so we can use the index. */
748	if (RT_LIKELY(pStream->fFullyLineated))
749	return scmStreamGetLineByNoCommon(pStream, iLine, pcchLine, penmEol);
750
751	int rc = pStream->rc;
752	if (RT_SUCCESS(rc))
753	{
754	rc = scmStreamLineate(pStream);
755	if (RT_SUCCESS(rc))
756	return scmStreamGetLineByNoCommon(pStream, iLine, pcchLine, penmEol);
757	}
758
759	*pcchLine = 0;
760	*penmEol = SCMEOL_NONE;
761	return NULL;
762	}
763
764	/**
765	* Get a line from the stream.
766	*
767	* A line is always delimited by a LF character or the end of the stream. The
768	* delimiter is not included in returned line length, but instead returned via
769	* the @a penmEol indicator.
770	*
771	* @returns Pointer to the first character in the line, not NULL terminated.
772	* NULL if the end of the stream has been reached or some problem
773	* occurred (pcchLine set to zero and penmEol to SCMEOL_NONE).
774	*
775	* @param pStream The stream. Must be in read mode.
776	* @param pcchLine The length.
777	* @param penmEol Where to return the end of line type indicator.
778	*/
779	const char ScmStreamGetLine(PSCMSTREAM pStream, size_t pcchLine, PSCMEOL penmEol)
780	{
781	if (RT_LIKELY(pStream->fFullyLineated))
782	{
783	size_t offCur = pStream->off;
784	size_t iCurLine = pStream->iLine;
785	const char *pszLine = scmStreamGetLineByNoCommon(pStream, iCurLine, pcchLine, penmEol);
786	if ( pszLine
787	&& offCur > pStream->paLines[iCurLine].off)
788	{
789	offCur -= pStream->paLines[iCurLine].off;
790	Assert(offCur <= pStream->paLines[iCurLine].cch + pStream->paLines[iCurLine].enmEol);
791	if (offCur < pStream->paLines[iCurLine].cch)
792	*pcchLine -= offCur;
793	else
794	*pcchLine = 0;
795	pszLine += offCur;
796	}
797	return pszLine;
798	}
799	return scmStreamGetLineInternal(pStream, pcchLine, penmEol);
800	}
801
802	/**
803	* Get the current buffer pointer.
804	*
805	* @returns Buffer pointer on success, NULL on failure (asserted).
806	* @param pStream The stream. Must be in read mode.
807	*/
808	const char *ScmStreamGetCur(PSCMSTREAM pStream)
809	{
810	AssertReturn(!pStream->fWriteOrRead, NULL);
811	return pStream->pch + pStream->off;
812	}
813
814	/**
815	* Gets a character from the stream.
816	*
817	* @returns The next unsigned character in the stream.
818	* ~(unsigned)0 on failure.
819	* @param pStream The stream. Must be in read mode.
820	*/
821	unsigned ScmStreamGetCh(PSCMSTREAM pStream)
822	{
823	/* Check stream state. */
824	AssertReturn(!pStream->fWriteOrRead, ~(unsigned)0);
825	if (RT_FAILURE(pStream->rc))
826	return ~(unsigned)0;
827	if (RT_UNLIKELY(!pStream->fFullyLineated))
828	{
829	int rc = scmStreamLineate(pStream);
830	if (RT_FAILURE(rc))
831	return ~(unsigned)0;
832	}
833
834	/* If there isn't enough stream left, fail already. */
835	if (RT_UNLIKELY(pStream->off >= pStream->cb))
836	return ~(unsigned)0;
837
838	/* Read a character. */
839	char ch = pStream->pch[pStream->off++];
840
841	/* Advance the line indicator. */
842	size_t iLine = pStream->iLine;
843	if (pStream->off >= pStream->paLines[iLine].off + pStream->paLines[iLine].cch + pStream->paLines[iLine].enmEol)
844	pStream->iLine++;
845
846	return (unsigned)ch;
847	}
848
849
850	/**
851	* Peeks at the next character from the stream.
852	*
853	* @returns The next unsigned character in the stream.
854	* ~(unsigned)0 on failure.
855	* @param pStream The stream. Must be in read mode.
856	*/
857	unsigned ScmStreamPeekCh(PSCMSTREAM pStream)
858	{
859	/* Check stream state. */
860	AssertReturn(!pStream->fWriteOrRead, ~(unsigned)0);
861	if (RT_FAILURE(pStream->rc))
862	return ~(unsigned)0;
863	if (RT_UNLIKELY(!pStream->fFullyLineated))
864	{
865	int rc = scmStreamLineate(pStream);
866	if (RT_FAILURE(rc))
867	return ~(unsigned)0;
868	}
869
870	/* If there isn't enough stream left, fail already. */
871	if (RT_UNLIKELY(pStream->off >= pStream->cb))
872	return ~(unsigned)0;
873
874	/* Peek at the next character. */
875	char ch = pStream->pch[pStream->off];
876	return (unsigned)ch;
877	}
878
879
880	/**
881	* Reads @a cbToRead bytes into @a pvBuf.
882	*
883	* Will fail if end of stream is encountered before the entire read has been
884	* completed.
885	*
886	* @returns IPRT status code.
887	* @retval VERR_EOF if there isn't @a cbToRead bytes left to read. Stream
888	* position will be unchanged.
889	*
890	* @param pStream The stream. Must be in read mode.
891	* @param pvBuf The buffer to read into.
892	* @param cbToRead The number of bytes to read.
893	*/
894	int ScmStreamRead(PSCMSTREAM pStream, void *pvBuf, size_t cbToRead)
895	{
896	AssertReturn(!pStream->fWriteOrRead, VERR_PERMISSION_DENIED);
897	if (RT_FAILURE(pStream->rc))
898	return pStream->rc;
899
900	/* If there isn't enough stream left, fail already. */
901	if (RT_UNLIKELY(pStream->cb - pStream->off < cbToRead))
902	return VERR_EOF;
903
904	/* Copy the data and simply seek to the new stream position. */
905	memcpy(pvBuf, &pStream->pch[pStream->off], cbToRead);
906	return ScmStreamSeekAbsolute(pStream, pStream->off + cbToRead);
907	}
908
909
910	/**
911	* Checks if the given line is empty or full of white space.
912	*
913	* @returns true if white space only, false if not (or if non-existant).
914	* @param pStream The stream. Must be in read mode.
915	* @param iLine The line in question.
916	*/
917	bool ScmStreamIsWhiteLine(PSCMSTREAM pStream, size_t iLine)
918	{
919	SCMEOL enmEol;
920	size_t cchLine;
921	const char *pchLine = ScmStreamGetLineByNo(pStream, iLine, &cchLine, &enmEol);
922	if (!pchLine)
923	return false;
924	while (cchLine && RT_C_IS_SPACE(*pchLine))
925	pchLine++, cchLine--;
926	return cchLine == 0;
927	}
928
929
930	/**
931	* Try figure out the end of line style of the give stream.
932	*
933	* @returns Most likely end of line style.
934	* @param pStream The stream.
935	*/
936	SCMEOL ScmStreamGetEol(PSCMSTREAM pStream)
937	{
938	SCMEOL enmEol;
939	if (pStream->cLines > 0)
940	enmEol = pStream->paLines[0].enmEol;
941	else if (pStream->cb == 0)
942	enmEol = SCMEOL_NONE;
943	else
944	{
945	const char pchLF = (const char )memchr(pStream->pch, '\n', pStream->cb);
946	if (pchLF && pchLF != pStream->pch && pchLF[-1] == '\r')
947	enmEol = SCMEOL_CRLF;
948	else
949	enmEol = SCMEOL_LF;
950	}
951
952	if (enmEol == SCMEOL_NONE)
953	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
954	enmEol = SCMEOL_CRLF;
955	#else
956	enmEol = SCMEOL_LF;
957	#endif
958	return enmEol;
959	}
960
961
962	/**
963	* Get the end of line indicator type for a line.
964	*
965	* @returns The EOL indicator. If the line isn't found, the default EOL
966	* indicator is return.
967	* @param pStream The stream.
968	* @param iLine The line (0-base).
969	*/
970	SCMEOL ScmStreamGetEolByLine(PSCMSTREAM pStream, size_t iLine)
971	{
972	SCMEOL enmEol;
973	if (iLine < pStream->cLines)
974	enmEol = pStream->paLines[iLine].enmEol;
975	else
976	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
977	enmEol = SCMEOL_CRLF;
978	#else
979	enmEol = SCMEOL_LF;
980	#endif
981	return enmEol;
982	}
983
984
985	/**
986	* Appends a line to the stream.
987	*
988	* @returns IPRT status code.
989	* @param pStream The stream. Must be in write mode.
990	* @param pchLine Pointer to the line.
991	* @param cchLine Line length.
992	* @param enmEol Which end of line indicator to use.
993	*/
994	int ScmStreamPutLine(PSCMSTREAM pStream, const char *pchLine, size_t cchLine, SCMEOL enmEol)
995	{
996	AssertReturn(pStream->fWriteOrRead, VERR_ACCESS_DENIED);
997	if (RT_FAILURE(pStream->rc))
998	return pStream->rc;
999
1000	/*
1001	* Make sure the previous line has a new-line indicator.
1002	*/
1003	size_t off = pStream->off;
1004	size_t iLine = pStream->iLine;
1005	if (RT_UNLIKELY( iLine != 0
1006	&& pStream->paLines[iLine - 1].enmEol == SCMEOL_NONE))
1007	{
1008	AssertReturn(pStream->paLines[iLine].cch == 0, VERR_INTERNAL_ERROR_3);
1009	SCMEOL enmEol2 = enmEol != SCMEOL_NONE ? enmEol : ScmStreamGetEol(pStream);
1010	if (RT_UNLIKELY(off + cchLine + enmEol + enmEol2 > pStream->cbAllocated))
1011	{
1012	int rc = scmStreamGrowBuffer(pStream, cchLine + enmEol + enmEol2);
1013	if (RT_FAILURE(rc))
1014	return rc;
1015	}
1016	if (enmEol2 == SCMEOL_LF)
1017	pStream->pch[off++] = '\n';
1018	else
1019	{
1020	pStream->pch[off++] = '\r';
1021	pStream->pch[off++] = '\n';
1022	}
1023	pStream->paLines[iLine - 1].enmEol = enmEol2;
1024	pStream->paLines[iLine].off = off;
1025	pStream->off = off;
1026	pStream->cb = off;
1027	}
1028
1029	/*
1030	* Ensure we've got sufficient buffer space.
1031	*/
1032	if (RT_UNLIKELY(off + cchLine + enmEol > pStream->cbAllocated))
1033	{
1034	int rc = scmStreamGrowBuffer(pStream, cchLine + enmEol);
1035	if (RT_FAILURE(rc))
1036	return rc;
1037	}
1038
1039	/*
1040	* Add a line record.
1041	*/
1042	if (RT_UNLIKELY(iLine + 1 >= pStream->cLinesAllocated))
1043	{
1044	int rc = scmStreamGrowLines(pStream, iLine);
1045	if (RT_FAILURE(rc))
1046	return rc;
1047	}
1048
1049	pStream->paLines[iLine].cch = off - pStream->paLines[iLine].off + cchLine;
1050	pStream->paLines[iLine].enmEol = enmEol;
1051
1052	iLine++;
1053	pStream->cLines = iLine;
1054	pStream->iLine = iLine;
1055
1056	/*
1057	* Copy the line
1058	*/
1059	memcpy(&pStream->pch[off], pchLine, cchLine);
1060	off += cchLine;
1061	if (enmEol == SCMEOL_LF)
1062	pStream->pch[off++] = '\n';
1063	else if (enmEol == SCMEOL_CRLF)
1064	{
1065	pStream->pch[off++] = '\r';
1066	pStream->pch[off++] = '\n';
1067	}
1068	pStream->off = off;
1069	pStream->cb = off;
1070
1071	/*
1072	* Start a new line.
1073	*/
1074	pStream->paLines[iLine].off = off;
1075	pStream->paLines[iLine].cch = 0;
1076	pStream->paLines[iLine].enmEol = SCMEOL_NONE;
1077
1078	return VINF_SUCCESS;
1079	}
1080
1081	/**
1082	* Writes to the stream.
1083	*
1084	* @returns IPRT status code
1085	* @param pStream The stream. Must be in write mode.
1086	* @param pchBuf What to write.
1087	* @param cchBuf How much to write.
1088	*/
1089	int ScmStreamWrite(PSCMSTREAM pStream, const char *pchBuf, size_t cchBuf)
1090	{
1091	AssertReturn(pStream->fWriteOrRead, VERR_ACCESS_DENIED);
1092	if (RT_FAILURE(pStream->rc))
1093	return pStream->rc;
1094
1095	/*
1096	* Ensure we've got sufficient buffer space.
1097	*/
1098	size_t off = pStream->off;
1099	if (RT_UNLIKELY(off + cchBuf > pStream->cbAllocated))
1100	{
1101	int rc = scmStreamGrowBuffer(pStream, cchBuf);
1102	if (RT_FAILURE(rc))
1103	return rc;
1104	}
1105
1106	/*
1107	* Deal with the odd case where we've already pushed a line with SCMEOL_NONE.
1108	*/
1109	size_t iLine = pStream->iLine;
1110	if (RT_UNLIKELY( iLine > 0
1111	&& pStream->paLines[iLine - 1].enmEol == SCMEOL_NONE))
1112	{
1113	iLine--;
1114	pStream->cLines = iLine;
1115	pStream->iLine = iLine;
1116	}
1117
1118	/*
1119	* Deal with lines.
1120	*/
1121	const char pchLF = (const char )memchr(pchBuf, '\n', cchBuf);
1122	if (!pchLF)
1123	pStream->paLines[iLine].cch += cchBuf;
1124	else
1125	{
1126	const char *pchLine = pchBuf;
1127	for (;;)
1128	{
1129	if (RT_UNLIKELY(iLine + 1 >= pStream->cLinesAllocated))
1130	{
1131	int rc = scmStreamGrowLines(pStream, iLine);
1132	if (RT_FAILURE(rc))
1133	{
1134	iLine = pStream->iLine;
1135	pStream->paLines[iLine].cch = off - pStream->paLines[iLine].off;
1136	pStream->paLines[iLine].enmEol = SCMEOL_NONE;
1137	return rc;
1138	}
1139	}
1140
1141	size_t cchLine = pchLF - pchLine;
1142	if ( cchLine
1143	? pchLF[-1] != '\r'
1144	: !pStream->paLines[iLine].cch
1145	\|\| pStream->pch[pStream->paLines[iLine].off + pStream->paLines[iLine].cch - 1] != '\r')
1146	pStream->paLines[iLine].enmEol = SCMEOL_LF;
1147	else
1148	{
1149	pStream->paLines[iLine].enmEol = SCMEOL_CRLF;
1150	cchLine--;
1151	}
1152	pStream->paLines[iLine].cch += cchLine;
1153
1154	iLine++;
1155	size_t offBuf = pchLF + 1 - pchBuf;
1156	pStream->paLines[iLine].off = off + offBuf;
1157	pStream->paLines[iLine].cch = 0;
1158	pStream->paLines[iLine].enmEol = SCMEOL_NONE;
1159
1160	size_t cchLeft = cchBuf - offBuf;
1161	pchLine = pchLF + 1;
1162	pchLF = (const char *)memchr(pchLine, '\n', cchLeft);
1163	if (!pchLF)
1164	{
1165	pStream->paLines[iLine].cch = cchLeft;
1166	break;
1167	}
1168	}
1169
1170	pStream->iLine = iLine;
1171	pStream->cLines = iLine;
1172	}
1173
1174	/*
1175	* Copy the data and update position and size.
1176	*/
1177	memcpy(&pStream->pch[off], pchBuf, cchBuf);
1178	off += cchBuf;
1179	pStream->off = off;
1180	pStream->cb = off;
1181
1182	return VINF_SUCCESS;
1183	}
1184
1185	/**
1186	* Write a character to the stream.
1187	*
1188	* @returns IPRT status code
1189	* @param pStream The stream. Must be in write mode.
1190	* @param pchBuf What to write.
1191	* @param cchBuf How much to write.
1192	*/
1193	int ScmStreamPutCh(PSCMSTREAM pStream, char ch)
1194	{
1195	AssertReturn(pStream->fWriteOrRead, VERR_ACCESS_DENIED);
1196	if (RT_FAILURE(pStream->rc))
1197	return pStream->rc;
1198
1199	/*
1200	* Only deal with the simple cases here, use ScmStreamWrite for the
1201	* annoying stuff.
1202	*/
1203	size_t off = pStream->off;
1204	if ( ch == '\n'
1205	\|\| RT_UNLIKELY(off + 1 > pStream->cbAllocated))
1206	return ScmStreamWrite(pStream, &ch, 1);
1207
1208	/*
1209	* Just append it.
1210	*/
1211	pStream->pch[off] = ch;
1212	pStream->off = off + 1;
1213	pStream->paLines[pStream->iLine].cch++;
1214
1215	return VINF_SUCCESS;
1216	}
1217
1218	/**
1219	* Puts an EOL marker to the stream.
1220	*
1221	* @returns IPRt status code.
1222	* @param pStream The stream. Must be in write mode.
1223	* @param enmEol The end-of-line marker to write.
1224	*/
1225	int ScmStreamPutEol(PSCMSTREAM pStream, SCMEOL enmEol)
1226	{
1227	if (enmEol == SCMEOL_LF)
1228	return ScmStreamWrite(pStream, "\n", 1);
1229	if (enmEol == SCMEOL_CRLF)
1230	return ScmStreamWrite(pStream, "\r\n", 2);
1231	if (enmEol == SCMEOL_NONE)
1232	return VINF_SUCCESS;
1233	AssertFailedReturn(VERR_INVALID_PARAMETER);
1234	}
1235
1236	/**
1237	* Formats a string and writes it to the SCM stream.
1238	*
1239	* @returns The number of bytes written (>= 0). Negative value are IPRT error
1240	* status codes.
1241	* @param pStream The stream to write to.
1242	* @param pszFormat The format string.
1243	* @param va The arguments to format.
1244	*/
1245	ssize_t ScmStreamPrintfV(PSCMSTREAM pStream, const char *pszFormat, va_list va)
1246	{
1247	char *psz;
1248	ssize_t cch = RTStrAPrintfV(&psz, pszFormat, va);
1249	if (cch)
1250	{
1251	int rc = ScmStreamWrite(pStream, psz, cch);
1252	RTStrFree(psz);
1253	if (RT_FAILURE(rc))
1254	cch = rc;
1255	}
1256	return cch;
1257	}
1258
1259	/**
1260	* Formats a string and writes it to the SCM stream.
1261	*
1262	* @returns The number of bytes written (>= 0). Negative value are IPRT error
1263	* status codes.
1264	* @param pStream The stream to write to.
1265	* @param pszFormat The format string.
1266	* @param ... The arguments to format.
1267	*/
1268	ssize_t ScmStreamPrintf(PSCMSTREAM pStream, const char *pszFormat, ...)
1269	{
1270	va_list va;
1271	va_start(va, pszFormat);
1272	ssize_t cch = ScmStreamPrintfV(pStream, pszFormat, va);
1273	va_end(va);
1274	return cch;
1275	}
1276
1277	/**
1278	* Copies @a cLines from the @a pSrc stream onto the @a pDst stream.
1279	*
1280	* The stream positions will be used and changed in both streams.
1281	*
1282	* @returns IPRT status code.
1283	* @param pDst The destination stream. Must be in write mode.
1284	* @param cLines The number of lines. (0 is accepted.)
1285	* @param pSrc The source stream. Must be in read mode.
1286	*/
1287	int ScmStreamCopyLines(PSCMSTREAM pDst, PSCMSTREAM pSrc, size_t cLines)
1288	{
1289	AssertReturn(pDst->fWriteOrRead, VERR_ACCESS_DENIED);
1290	if (RT_FAILURE(pDst->rc))
1291	return pDst->rc;
1292
1293	AssertReturn(!pSrc->fWriteOrRead, VERR_ACCESS_DENIED);
1294	if (RT_FAILURE(pSrc->rc))
1295	return pSrc->rc;
1296
1297	while (cLines-- > 0)
1298	{
1299	SCMEOL enmEol;
1300	size_t cchLine;
1301	const char *pchLine = ScmStreamGetLine(pSrc, &cchLine, &enmEol);
1302	if (!pchLine)
1303	return pDst->rc = RT_FAILURE(pSrc->rc) ? pSrc->rc : VERR_EOF;
1304
1305	int rc = ScmStreamPutLine(pDst, pchLine, cchLine, enmEol);
1306	if (RT_FAILURE(rc))
1307	return rc;
1308	}
1309
1310	return VINF_SUCCESS;
1311	}
1312
1313
1314	/**
1315	* If the given C word is at off - 1, return @c true and skip beyond it,
1316	* otherwise return @c false.
1317	*
1318	* @retval true if the given C-word is at the current position minus one char.
1319	* The stream position changes.
1320	* @retval false if not. The stream position is unchanged.
1321	*
1322	* @param pStream The stream.
1323	* @param cchWord The length of the word.
1324	* @param pszWord The word.
1325	*/
1326	bool ScmStreamCMatchingWordM1(PSCMSTREAM pStream, const char *pszWord, size_t cchWord)
1327	{
1328	/* Check stream state. */
1329	AssertReturn(!pStream->fWriteOrRead, false);
1330	AssertReturn(RT_SUCCESS(pStream->rc), false);
1331	AssertReturn(pStream->fFullyLineated, false);
1332
1333	/* Sufficient chars left on the line? */
1334	size_t const iLine = pStream->iLine;
1335	AssertReturn(pStream->off > pStream->paLines[iLine].off, false);
1336	size_t const cchLeft = pStream->paLines[iLine].cch + pStream->paLines[iLine].off - (pStream->off - 1);
1337	if (cchWord > cchLeft)
1338	return false;
1339
1340	/* Do they match? */
1341	const char *psz = &pStream->pch[pStream->off - 1];
1342	if (memcmp(psz, pszWord, cchWord))
1343	return false;
1344
1345	/* Is it the end of a C word? */
1346	if (cchWord < cchLeft)
1347	{
1348	psz += cchWord;
1349	if (RT_C_IS_ALNUM(psz) \|\| psz == '_')
1350	return false;
1351	}
1352
1353	/* Skip ahead. */
1354	pStream->off += cchWord - 1;
1355	return true;
1356	}
1357
1358
1359	/**
1360	* Get's the C word starting at the current position.
1361	*
1362	* @returns Pointer to the word on success and the stream position advanced to
1363	* the end of it.
1364	* NULL on failure, stream position normally unchanged.
1365	* @param pStream The stream to get the C word from.
1366	* @param pcchWord Where to return the word length.
1367	*/
1368	const char ScmStreamCGetWord(PSCMSTREAM pStream, size_t pcchWord)
1369	{
1370	/* Check stream state. */
1371	AssertReturn(!pStream->fWriteOrRead, NULL);
1372	AssertReturn(RT_SUCCESS(pStream->rc), NULL);
1373	AssertReturn(pStream->fFullyLineated, NULL);
1374
1375	/* Get the number of chars left on the line and locate the current char. */
1376	size_t const iLine = pStream->iLine;
1377	size_t const cchLeft = pStream->paLines[iLine].cch + pStream->paLines[iLine].off - pStream->off;
1378	const char *psz = &pStream->pch[pStream->off];
1379
1380	/* Is it a leading C character. */
1381	if (!RT_C_IS_ALPHA(psz) && psz != '_')
1382	return NULL;
1383
1384	/* Find the end of the word. */
1385	char ch;
1386	size_t off = 1;
1387	while ( off < cchLeft
1388	&& ( (ch = psz[off]) == '_'
1389	\|\| RT_C_IS_ALNUM(ch)))
1390	off++;
1391
1392	pStream->off += off;
1393	*pcchWord = off;
1394	return psz;
1395	}
1396
1397
1398	/**
1399	* Get's the C word starting at the current position minus one.
1400	*
1401	* @returns Pointer to the word on success and the stream position advanced to
1402	* the end of it.
1403	* NULL on failure, stream position normally unchanged.
1404	* @param pStream The stream to get the C word from.
1405	* @param pcchWord Where to return the word length.
1406	*/
1407	const char ScmStreamCGetWordM1(PSCMSTREAM pStream, size_t pcchWord)
1408	{
1409	/* Check stream state. */
1410	AssertReturn(!pStream->fWriteOrRead, NULL);
1411	AssertReturn(RT_SUCCESS(pStream->rc), NULL);
1412	AssertReturn(pStream->fFullyLineated, NULL);
1413
1414	/* Get the number of chars left on the line and locate the current char. */
1415	size_t const iLine = pStream->iLine;
1416	size_t const cchLeft = pStream->paLines[iLine].cch + pStream->paLines[iLine].off - (pStream->off - 1);
1417	const char *psz = &pStream->pch[pStream->off - 1];
1418
1419	/* Is it a leading C character. */
1420	if (!RT_C_IS_ALPHA(psz) && psz != '_')
1421	return NULL;
1422
1423	/* Find the end of the word. */
1424	char ch;
1425	size_t off = 1;
1426	while ( off < cchLeft
1427	&& ( (ch = psz[off]) == '_'
1428	\|\| RT_C_IS_ALNUM(ch)))
1429	off++;
1430
1431	pStream->off += off - 1;
1432	*pcchWord = off;
1433	return psz;
1434	}
1435

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

source: vbox/trunk/src/bldprogs/scmstream.cpp@ 84250

Download in other formats: