VirtualBox

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

Last change on this file since 76409 was 69500, checked in by vboxsync, 7 years ago

*: scm --update-copyright-year
  • 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 69500 2017-10-28 15:14:05Z 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 */
40static 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 */
66int 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 */
90int 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 */
131void 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 */
157int 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 */
170static 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 */
203static 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 */
222void 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 */
235void 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 */
253bool 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 */
268int 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 */
305int 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 */
340int 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 */
385static 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 */
443static 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 */
469size_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 */
480size_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 */
494size_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 */
514size_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 */
525size_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 */
544int 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 */
598int 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 */
619int 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 */
653bool 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 */
679DECLINLINE(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 */
725const 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 */
761const 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 */
790const 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 */
803unsigned 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 */
839unsigned 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 */
876int 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 */
899bool 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 */
917SCMEOL 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 */
950SCMEOL 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 */
973int 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 */
1068int 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 */
1172int 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 */
1204int 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 */
1224ssize_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 */
1247ssize_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 */
1266int 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 */
1305bool 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 */
1346const 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 */
1385const 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.

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