scmstream.cpp@ 76451

Last change on this file since 76451 was 76451, checked in by vboxsync, 6 years ago
scm: Added crude pass for adjusting err.h to errcore.h when possible. Currently disabled.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 41.1 KB

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

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

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

Download in other formats: