scmparser.cpp@ 74856

Last change on this file since 74856 was 69460, checked in by vboxsync, 7 years ago
scm: build fix
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.1 KB

Line
1	/* $Id: scmparser.cpp 69460 2017-10-27 17:28:22Z vboxsync $ */
2	/** @file
3	* IPRT Testcase / Tool - Source Code Massager, Code Parsers.
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/dir.h>
25	#include <iprt/env.h>
26	#include <iprt/file.h>
27	#include <iprt/err.h>
28	#include <iprt/getopt.h>
29	#include <iprt/initterm.h>
30	#include <iprt/mem.h>
31	#include <iprt/message.h>
32	#include <iprt/param.h>
33	#include <iprt/path.h>
34	#include <iprt/process.h>
35	#include <iprt/stream.h>
36	#include <iprt/string.h>
37
38	#include "scm.h"
39
40
41	/*********************************************************************************************************************************
42	* Structures and Typedefs *
43	*********************************************************************************************************************************/
44	typedef size_t (PFNISCOMMENT)(const char pchLine, size_t cchLine, bool fSecond);
45
46
47	/**
48	* Callback for checking if C++ line comment.
49	*/
50	static size_t isCppLineComment(const char *pchLine, size_t cchLine, bool fSecond)
51	{
52	if ( cchLine >= 2
53	&& pchLine[0] == '/'
54	&& pchLine[1] == '/')
55	{
56	if (!fSecond)
57	return 2;
58	if (cchLine >= 3 && pchLine[2] == '/')
59	return 3;
60	}
61	return 0;
62	}
63
64
65	/**
66	* Callback for checking if hash comment.
67	*/
68	static size_t isHashComment(const char *pchLine, size_t cchLine, bool fSecond)
69	{
70	if (cchLine >= 1 && *pchLine == '#')
71	{
72	if (!fSecond)
73	return 1;
74	if (cchLine >= 2 && pchLine[1] == '#')
75	return 2;
76	}
77	return 0;
78	}
79
80
81	/**
82	* Callback for checking if semicolon comment.
83	*/
84	static size_t isSemicolonComment(const char *pchLine, size_t cchLine, bool fSecond)
85	{
86	if (cchLine >= 1 && *pchLine == ';')
87	{
88	if (!fSecond)
89	return 1;
90	if (cchLine >= 2 && pchLine[1] == ';')
91	return 2;
92	}
93	return 0;
94	}
95
96
97	/** Macro for checking for a batch file comment prefix. */
98	#define IS_REM(a_pch, a_off, a_cch) \
99	( (a_off) + 3 <= (a_cch) \
100	&& ((a_pch)[(a_off) ] == 'R' \|\| (a_pch)[(a_off) ] == 'r') \
101	&& ((a_pch)[(a_off) + 1] == 'E' \|\| (a_pch)[(a_off) + 1] == 'e') \
102	&& ((a_pch)[(a_off) + 2] == 'M' \|\| (a_pch)[(a_off) + 2] == 'm') \
103	&& ((a_off) + 3 == (a_cch) \|\| RT_C_IS_SPACE((a_pch)[(a_off) + 3])) )
104
105
106	/**
107	* Callback for checking if batch comment.
108	*/
109	static size_t isBatchComment(const char *pchLine, size_t cchLine, bool fSecond)
110	{
111	if (!fSecond)
112	{
113	if (IS_REM(pchLine, 0, cchLine))
114	return 3;
115	}
116	else
117	{
118	/* Check for the 2nd in "rem rem" lines. */
119	if ( cchLine >= 4
120	&& RT_C_IS_SPACE(*pchLine)
121	&& IS_REM(pchLine, 1, cchLine))
122	return 4;
123	}
124	return 0;
125	}
126
127	/**
128	* Callback for checking if SQL comment.
129	*/
130	static size_t isSqlComment(const char *pchLine, size_t cchLine, bool fSecond)
131	{
132	if ( cchLine >= 2
133	&& pchLine[0] == '-'
134	&& pchLine[1] == '-')
135	{
136	if (!fSecond)
137	return 2;
138	if ( cchLine >= 3
139	&& pchLine[2] == '-')
140	return 3;
141	}
142	return 0;
143	}
144
145	/**
146	* Callback for checking if tick comment.
147	*/
148	static size_t isTickComment(const char *pchLine, size_t cchLine, bool fSecond)
149	{
150	if (cchLine >= 1 && *pchLine == '\'')
151	{
152	if (!fSecond)
153	return 1;
154	if (cchLine >= 2 && pchLine[1] == '\'')
155	return 2;
156	}
157	return 0;
158	}
159
160
161	/**
162	* Common worker for enumeratePythonComments and enumerateSimpleLineComments.
163	*
164	* @returns IPRT status code.
165	* @param pIn The input stream.
166	* @param pfnIsComment Comment tester function.
167	* @param pfnCallback The callback.
168	* @param pvUser The user argument for the callback.
169	* @param ppchLine Pointer to the line variable.
170	* @param pcchLine Pointer to the line length variable.
171	* @param penmEol Pointer to the line ending type variable.
172	* @param piLine Pointer to the line number variable.
173	* @param poff Pointer to the line offset variable. On input this
174	* is positioned at the start of the comment.
175	*/
176	static int handleLineComment(PSCMSTREAM pIn, PFNISCOMMENT pfnIsComment,
177	PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser,
178	const char *ppchLine, size_t pcchLine, PSCMEOL penmEol,
179	uint32_t piLine, size_t poff)
180	{
181	/* Unpack input/output variables. */
182	uint32_t iLine = *piLine;
183	const char pchLine = ppchLine;
184	size_t cchLine = *pcchLine;
185	size_t off = *poff;
186	SCMEOL enmEol = *penmEol;
187
188	/*
189	* Take down the basic info about the comment.
190	*/
191	SCMCOMMENTINFO Info;
192	Info.iLineStart = iLine;
193	Info.iLineEnd = iLine;
194	Info.offStart = (uint32_t)off;
195	Info.offEnd = (uint32_t)cchLine;
196
197	size_t cchSkip = pfnIsComment(&pchLine[off], cchLine - off, false);
198	Assert(cchSkip > 0);
199	off += cchSkip;
200
201	/* Determin comment type. */
202	Info.enmType = kScmCommentType_Line;
203	char ch;
204	cchSkip = 1;
205	if ( off < cchLine
206	&& ( (ch = pchLine[off]) == '!'
207	\|\| (cchSkip = pfnIsComment(&pchLine[off], cchLine - off, true)) > 0) )
208	{
209	unsigned ch2;
210	if ( off + cchSkip == cchLine
211	\|\| RT_C_IS_SPACE(ch2 = pchLine[off + cchSkip]) )
212	{
213	Info.enmType = ch != '!' ? kScmCommentType_Line_JavaDoc : kScmCommentType_Line_Qt;
214	off += cchSkip;
215	}
216	else if ( ch2 == '<'
217	&& ( off + cchSkip + 1 == cchLine
218	\|\| RT_C_IS_SPACE(pchLine[off + cchSkip + 1]) ))
219	{
220	Info.enmType = ch == '!' ? kScmCommentType_Line_JavaDoc_After : kScmCommentType_Line_Qt_After;
221	off += cchSkip + 1;
222	}
223	}
224
225	/*
226	* Copy body of the first line. Like for C, we ignore a single space in the first comment line.
227	*/
228	if (off < cchLine && RT_C_IS_SPACE(pchLine[off]))
229	off++;
230	size_t cchBody = cchLine;
231	while (cchBody > off && RT_C_IS_SPACE(pchLine[cchBody - 1]))
232	cchBody--;
233	cchBody -= off;
234	size_t cbBodyAlloc = RT_MAX(_1K, RT_ALIGN_Z(cchBody + 64, 128));
235	char pszBody = (char )RTMemAlloc(cbBodyAlloc);
236	if (!pszBody)
237	return VERR_NO_MEMORY;
238	memcpy(pszBody, &pchLine[off], cchBody);
239	pszBody[cchBody] = '\0';
240
241	Info.cBlankLinesBefore = cchBody == 0;
242
243	/*
244	* Look for more comment lines and append them to the body.
245	*/
246	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
247	{
248	iLine++;
249
250	/* Skip leading spaces. */
251	off = 0;
252	while (off < cchLine && RT_C_IS_SPACE(pchLine[off]))
253	off++;
254
255	/* Check if it's a comment. */
256	if ( off >= cchLine
257	\|\| (cchSkip = pfnIsComment(&pchLine[off], cchLine - off, false)) == 0)
258	break;
259	off += cchSkip;
260
261	/* Split on doxygen comment start (if not already in one). */
262	if ( Info.enmType == kScmCommentType_Line
263	&& off + 1 < cchLine
264	&& ( pfnIsComment(&pchLine[off], cchLine - off, true) > 0
265	\|\| ( pchLine[off + 1] == '!'
266	&& ( off + 2 == cchLine
267	\|\| pchLine[off + 2] != '!') ) ) )
268	{
269	off -= cchSkip;
270	break;
271	}
272
273	/* Append the body w/o trailing spaces and some leading ones. */
274	if (off < cchLine && RT_C_IS_SPACE(pchLine[off]))
275	off++;
276	while (off < cchLine && off < Info.offStart + 3 && RT_C_IS_SPACE(pchLine[off]))
277	off++;
278	size_t cchAppend = cchLine;
279	while (cchAppend > off && RT_C_IS_SPACE(pchLine[cchAppend - 1]))
280	cchAppend--;
281	cchAppend -= off;
282
283	size_t cchNewBody = cchBody + 1 + cchAppend;
284	if (cchNewBody >= cbBodyAlloc)
285	{
286	cbBodyAlloc = RT_MAX(cbBodyAlloc ? cbBodyAlloc * 2 : _1K, RT_ALIGN_Z(cchNewBody + 64, 128));
287	void *pvNew = RTMemRealloc(pszBody, cbBodyAlloc);
288	if (pvNew)
289	pszBody = (char *)pvNew;
290	else
291	{
292	RTMemFree(pszBody);
293	return VERR_NO_MEMORY;
294	}
295	}
296
297	if ( cchBody > 0
298	\|\| cchAppend > 0)
299	{
300	if (cchBody > 0)
301	pszBody[cchBody++] = '\n';
302	memcpy(&pszBody[cchBody], &pchLine[off], cchAppend);
303	cchBody += cchAppend;
304	pszBody[cchBody] = '\0';
305	}
306	else
307	Info.cBlankLinesBefore++;
308
309	/* Advance. */
310	Info.offEnd = (uint32_t)cchLine;
311	Info.iLineEnd = iLine;
312	}
313
314	/*
315	* Strip trailing empty lines in the body.
316	*/
317	Info.cBlankLinesAfter = 0;
318	while (cchBody >= 1 && pszBody[cchBody - 1] == '\n')
319	{
320	Info.cBlankLinesAfter++;
321	pszBody[--cchBody] = '\0';
322	}
323
324	/*
325	* Do the callback and return.
326	*/
327	int rc = pfnCallback(&Info, pszBody, cchBody, pvUser);
328
329	RTMemFree(pszBody);
330
331	*piLine = iLine;
332	*ppchLine = pchLine;
333	*pcchLine = cchLine;
334	*poff = off;
335	*penmEol = enmEol;
336	return rc;
337	}
338
339
340
341	/**
342	* Common string litteral handler.
343	*
344	* @returns new pchLine value.
345	* @param pIn The input string.
346	* @param chType The quotation type.
347	* @param pchLine The current line.
348	* @param ppchLine Pointer to the line variable.
349	* @param pcchLine Pointer to the line length variable.
350	* @param penmEol Pointer to the line ending type variable.
351	* @param piLine Pointer to the line number variable.
352	* @param poff Pointer to the line offset variable.
353	*/
354	static const char handleStringLitteral(PSCMSTREAM pIn, char chType, const char pchLine, size_t *pcchLine, PSCMEOL penmEol,
355	uint32_t piLine, size_t poff)
356	{
357	size_t off = *poff;
358	for (;;)
359	{
360	bool fEnd = false;
361	bool fEscaped = false;
362	size_t const cchLine = *pcchLine;
363	while (off < cchLine)
364	{
365	char ch = pchLine[off++];
366	if (!fEscaped)
367	{
368	if (ch != chType)
369	{
370	if (ch != '\\')
371	{ /* likely */ }
372	else
373	fEscaped = true;
374	}
375	else
376	{
377	fEnd = true;
378	break;
379	}
380	}
381	else
382	fEscaped = false;
383	}
384	if (fEnd)
385	break;
386
387	/* next line */
388	pchLine = ScmStreamGetLine(pIn, pcchLine, penmEol);
389	if (!pchLine)
390	break;
391	*piLine += 1;
392	off = 0;
393	}
394
395	*poff = off;
396	return pchLine;
397	}
398
399
400	/**
401	* Deals with comments in C and C++ code.
402	*
403	* @returns VBox status code / callback return code.
404	* @param pIn The stream to parse.
405	* @param pfnCallback The callback.
406	* @param pvUser The user parameter for the callback.
407	*/
408	static int enumerateCStyleComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
409	{
410	AssertCompile('\'' < '/');
411	AssertCompile('"' < '/');
412
413	int rcRet = VINF_SUCCESS;
414	uint32_t iLine = 0;
415	SCMEOL enmEol;
416	size_t cchLine;
417	const char *pchLine;
418	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
419	{
420	size_t off = 0;
421	while (off < cchLine)
422	{
423	unsigned ch = pchLine[off++];
424	if (ch > (unsigned)'/')
425	{ /* not interesting */ }
426	else if (ch == '/')
427	{
428	if (off < cchLine)
429	{
430	ch = pchLine[off++];
431	if (ch == '*')
432	{
433	/*
434	* Multiline comment. Find the end.
435	*
436	* Note! This is very similar to the python doc string handling further down.
437	*/
438	SCMCOMMENTINFO Info;
439	Info.iLineStart = iLine;
440	Info.offStart = (uint32_t)off - 2;
441	Info.iLineEnd = UINT32_MAX;
442	Info.offEnd = UINT32_MAX;
443	Info.cBlankLinesBefore = 0;
444
445	/* Determin comment type (same as for line-comments). */
446	Info.enmType = kScmCommentType_MultiLine;
447	if ( off < cchLine
448	&& ( (ch = pchLine[off]) == '*'
449	\|\| ch == '!') )
450	{
451	unsigned ch2;
452	if ( off + 1 == cchLine
453	\|\| RT_C_IS_SPACE(ch2 = pchLine[off + 1]) )
454	{
455	Info.enmType = ch == '*' ? kScmCommentType_MultiLine_JavaDoc : kScmCommentType_MultiLine_Qt;
456	off += 1;
457	}
458	else if ( ch2 == '<'
459	&& ( off + 2 == cchLine
460	\|\| RT_C_IS_SPACE(pchLine[off + 2]) ))
461	{
462	Info.enmType = ch == '*' ? kScmCommentType_MultiLine_JavaDoc_After
463	: kScmCommentType_MultiLine_Qt_After;
464	off += 2;
465	}
466	}
467
468	/*
469	* Copy the body and find the end of the multiline comment.
470	*/
471	size_t cbBodyAlloc = 0;
472	size_t cchBody = 0;
473	char *pszBody = NULL;
474	for (;;)
475	{
476	/* Parse the line up to the end-of-comment or end-of-line. */
477	size_t offLineStart = off;
478	size_t offLastNonBlank = off;
479	size_t offFirstNonBlank = ~(size_t)0;
480	while (off < cchLine)
481	{
482	ch = pchLine[off++];
483	if (ch != '*' \|\| off >= cchLine \|\| pchLine[off] != '/')
484	{
485	if (RT_C_IS_BLANK(ch))
486	{/* kind of likely */}
487	else
488	{
489	offLastNonBlank = off - 1;
490	if (offFirstNonBlank != ~(size_t)0)
491	{/* likely */}
492	else if ( ch != '' / ignore continuation-asterisks */
493	\|\| off > Info.offStart + 1 + 1
494	\|\| off > cchLine
495	\|\| ( off < cchLine
496	&& !RT_C_IS_SPACE(pchLine[off]))
497	\|\| pszBody == NULL)
498	offFirstNonBlank = off - 1;
499	}
500	}
501	else
502	{
503	Info.offEnd = (uint32_t)++off;
504	Info.iLineEnd = iLine;
505	break;
506	}
507	}
508
509	/* Append line content to the comment body string. */
510	size_t cchAppend;
511	if (offFirstNonBlank == ~(size_t)0)
512	cchAppend = 0; /* empty line */
513	else
514	{
515	if (pszBody)
516	offLineStart = RT_MIN(Info.offStart + 3, offFirstNonBlank);
517	else if (offFirstNonBlank > Info.offStart + 2) /* Skip one leading blank at the start of the comment. */
518	offLineStart++;
519	cchAppend = offLastNonBlank + 1 - offLineStart;
520	Assert(cchAppend <= cchLine);
521	}
522
523	size_t cchNewBody = cchBody + (cchBody > 0) + cchAppend;
524	if (cchNewBody >= cbBodyAlloc)
525	{
526	cbBodyAlloc = RT_MAX(cbBodyAlloc ? cbBodyAlloc * 2 : _1K, RT_ALIGN_Z(cchNewBody + 64, 128));
527	void *pvNew = RTMemRealloc(pszBody, cbBodyAlloc);
528	if (pvNew)
529	pszBody = (char *)pvNew;
530	else
531	{
532	RTMemFree(pszBody);
533	return VERR_NO_MEMORY;
534	}
535	}
536
537	if (cchBody > 0) /* no leading blank lines */
538	pszBody[cchBody++] = '\n';
539	else if (cchAppend == 0)
540	Info.cBlankLinesBefore++;
541	memcpy(&pszBody[cchBody], &pchLine[offLineStart], cchAppend);
542	cchBody += cchAppend;
543	pszBody[cchBody] = '\0';
544
545	/* Advance to the next line, if we haven't yet seen the end of this comment. */
546	if (Info.iLineEnd != UINT32_MAX)
547	break;
548	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
549	if (!pchLine)
550	{
551	Info.offEnd = (uint32_t)cchLine;
552	Info.iLineEnd = iLine;
553	break;
554	}
555	iLine++;
556	off = 0;
557	}
558
559	/* Strip trailing empty lines in the body. */
560	Info.cBlankLinesAfter = 0;
561	while (cchBody >= 1 && pszBody[cchBody - 1] == '\n')
562	{
563	Info.cBlankLinesAfter++;
564	pszBody[--cchBody] = '\0';
565	}
566
567	/* Do the callback. */
568	int rc = pfnCallback(&Info, pszBody, cchBody, pvUser);
569	RTMemFree(pszBody);
570	if (RT_FAILURE(rc))
571	return rc;
572	if (rc > VINF_SUCCESS && rcRet == VINF_SUCCESS)
573	rcRet = rc;
574	}
575	else if (ch == '/')
576	{
577	/*
578	* Line comment. Join the other line comment guys.
579	*/
580	off -= 2;
581	int rc = handleLineComment(pIn, isCppLineComment, pfnCallback, pvUser,
582	&pchLine, &cchLine, &enmEol, &iLine, &off);
583	if (RT_FAILURE(rc))
584	return rc;
585	if (rcRet == VINF_SUCCESS)
586	rcRet = rc;
587	}
588
589	if (!pchLine)
590	break;
591	}
592	}
593	else if (ch == '"')
594	{
595	/*
596	* String litterals may include sequences that looks like comments. So,
597	* they needs special handling to avoid confusion.
598	*/
599	pchLine = handleStringLitteral(pIn, '"', pchLine, &cchLine, &enmEol, &iLine, &off);
600	}
601	/* else: We don't have to deal with character litterals as these shouldn't
602	include comment-like sequences. */
603	} /* for each character in the line */
604
605	iLine++;
606	} /* for each line in the stream */
607
608	int rcStream = ScmStreamGetStatus(pIn);
609	if (RT_SUCCESS(rcStream))
610	return rcRet;
611	return rcStream;
612	}
613
614
615	/**
616	* Deals with comments in Python code.
617	*
618	* @returns VBox status code / callback return code.
619	* @param pIn The stream to parse.
620	* @param pfnCallback The callback.
621	* @param pvUser The user parameter for the callback.
622	*/
623	static int enumeratePythonComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
624	{
625	AssertCompile('#' < '\'');
626	AssertCompile('"' < '\'');
627
628	int rcRet = VINF_SUCCESS;
629	uint32_t iLine = 0;
630	SCMEOL enmEol;
631	size_t cchLine;
632	const char *pchLine;
633	SCMCOMMENTINFO Info;
634	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
635	{
636	size_t off = 0;
637	while (off < cchLine)
638	{
639	char ch = pchLine[off++];
640	if ((unsigned char)ch > (unsigned char)'\'')
641	{ /* not interesting */ }
642	else if (ch == '#')
643	{
644	/*
645	* Line comment. Join paths with the others.
646	*/
647	off -= 1;
648	int rc = handleLineComment(pIn, isHashComment, pfnCallback, pvUser,
649	&pchLine, &cchLine, &enmEol, &iLine, &off);
650	if (RT_FAILURE(rc))
651	return rc;
652	if (rcRet == VINF_SUCCESS)
653	rcRet = rc;
654
655	if (!pchLine)
656	break;
657	}
658	else if (ch == '"' \|\| ch == '\'')
659	{
660	/*
661	* String litterals may be doc strings and they may legally include hashes.
662	*/
663	const char chType = ch;
664	if ( off + 1 >= cchLine
665	\|\| pchLine[off] != chType
666	\|\| pchLine[off + 1] != chType)
667	pchLine = handleStringLitteral(pIn, chType, pchLine, &cchLine, &enmEol, &iLine, &off);
668	else
669	{
670	/*
671	* Doc string (/ long string).
672	*
673	* Note! This is very similar to the multiline C comment handling above.
674	*/
675	Info.iLineStart = iLine;
676	Info.offStart = (uint32_t)off - 1;
677	Info.iLineEnd = UINT32_MAX;
678	Info.offEnd = UINT32_MAX;
679	Info.cBlankLinesBefore = 0;
680	Info.enmType = kScmCommentType_DocString;
681
682	off += 2;
683
684	/* Copy the body and find the end of the doc string comment. */
685	size_t cbBodyAlloc = 0;
686	size_t cchBody = 0;
687	char *pszBody = NULL;
688	for (;;)
689	{
690	/* Parse the line up to the end-of-comment or end-of-line. */
691	size_t offLineStart = off;
692	size_t offLastNonBlank = off;
693	size_t offFirstNonBlank = ~(size_t)0;
694	bool fEscaped = false;
695	while (off < cchLine)
696	{
697	ch = pchLine[off++];
698	if (!fEscaped)
699	{
700	if ( off + 1 >= cchLine
701	\|\| ch != chType
702	\|\| pchLine[off] != chType
703	\|\| pchLine[off + 1] != chType)
704	{
705	if (RT_C_IS_BLANK(ch))
706	{/* kind of likely */}
707	else
708	{
709	offLastNonBlank = off - 1;
710	if (offFirstNonBlank != ~(size_t)0)
711	{/* likely */}
712	else if ( ch != '' / ignore continuation-asterisks */
713	\|\| off > Info.offStart + 1 + 1
714	\|\| off > cchLine
715	\|\| ( off < cchLine
716	&& !RT_C_IS_SPACE(pchLine[off]))
717	\|\| pszBody == NULL)
718	offFirstNonBlank = off - 1;
719
720	if (ch != '\\')
721	{/* likely */ }
722	else
723	fEscaped = true;
724	}
725	}
726	else
727	{
728	off += 2;
729	Info.offEnd = (uint32_t)off;
730	Info.iLineEnd = iLine;
731	break;
732	}
733	}
734	else
735	fEscaped = false;
736	}
737
738	/* Append line content to the comment body string. */
739	size_t cchAppend;
740	if (offFirstNonBlank == ~(size_t)0)
741	cchAppend = 0; /* empty line */
742	else
743	{
744	if (pszBody)
745	offLineStart = RT_MIN(Info.offStart + 3, offFirstNonBlank);
746	else if (offFirstNonBlank > Info.offStart + 2) /* Skip one leading blank at the start of the comment. */
747	offLineStart++;
748	cchAppend = offLastNonBlank + 1 - offLineStart;
749	Assert(cchAppend <= cchLine);
750	}
751
752	size_t cchNewBody = cchBody + (cchBody > 0) + cchAppend;
753	if (cchNewBody >= cbBodyAlloc)
754	{
755	cbBodyAlloc = RT_MAX(cbBodyAlloc ? cbBodyAlloc * 2 : _1K, RT_ALIGN_Z(cchNewBody + 64, 128));
756	void *pvNew = RTMemRealloc(pszBody, cbBodyAlloc);
757	if (pvNew)
758	pszBody = (char *)pvNew;
759	else
760	{
761	RTMemFree(pszBody);
762	return VERR_NO_MEMORY;
763	}
764	}
765
766	if (cchBody > 0) /* no leading blank lines */
767	pszBody[cchBody++] = '\n';
768	else if (cchAppend == 0)
769	Info.cBlankLinesBefore++;
770	memcpy(&pszBody[cchBody], &pchLine[offLineStart], cchAppend);
771	cchBody += cchAppend;
772	pszBody[cchBody] = '\0';
773
774	/* Advance to the next line, if we haven't yet seen the end of this comment. */
775	if (Info.iLineEnd != UINT32_MAX)
776	break;
777	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
778	if (!pchLine)
779	{
780	Info.offEnd = (uint32_t)cchLine;
781	Info.iLineEnd = iLine;
782	break;
783	}
784	iLine++;
785	off = 0;
786	}
787
788	/* Strip trailing empty lines in the body. */
789	Info.cBlankLinesAfter = 0;
790	while (cchBody >= 1 && pszBody[cchBody - 1] == '\n')
791	{
792	Info.cBlankLinesAfter++;
793	pszBody[--cchBody] = '\0';
794	}
795
796	/* Do the callback. */
797	int rc = pfnCallback(&Info, pszBody, cchBody, pvUser);
798	RTMemFree(pszBody);
799	if (RT_FAILURE(rc))
800	return rc;
801	if (rc > VINF_SUCCESS && rcRet == VINF_SUCCESS)
802	rcRet = rc;
803	}
804
805	if (!pchLine)
806	break;
807	}
808	/* else: We don't have to deal with character litterals as these shouldn't
809	include comment-like sequences. */
810	} /* for each character in the line */
811
812	iLine++;
813	} /* for each line in the stream */
814
815	int rcStream = ScmStreamGetStatus(pIn);
816	if (RT_SUCCESS(rcStream))
817	return rcRet;
818	return rcStream;
819	}
820
821
822	/**
823	* Deals with comments in DOS batch files.
824	*
825	* @returns VBox status code / callback return code.
826	* @param pIn The stream to parse.
827	* @param pfnCallback The callback.
828	* @param pvUser The user parameter for the callback.
829	*/
830	static int enumerateBatchComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
831	{
832	int rcRet = VINF_SUCCESS;
833	uint32_t iLine = 0;
834	SCMEOL enmEol;
835	size_t cchLine;
836	const char *pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
837	while (pchLine != NULL)
838	{
839	/*
840	* Skip leading blanks and check for 'rem'.
841	* At the moment we do not parse '::lable-comments'.
842	*/
843	size_t off = 0;
844	while (off + 3 < cchLine && RT_C_IS_SPACE(pchLine[off]))
845	off++;
846	if (!IS_REM(pchLine, off, cchLine))
847	{
848	iLine++;
849	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
850	}
851	else
852	{
853	int rc = handleLineComment(pIn, isBatchComment, pfnCallback, pvUser,
854	&pchLine, &cchLine, &enmEol, &iLine, &off);
855	if (RT_FAILURE(rc))
856	return rc;
857	if (rcRet == VINF_SUCCESS)
858	rcRet = rc;
859	}
860	}
861
862	int rcStream = ScmStreamGetStatus(pIn);
863	if (RT_SUCCESS(rcStream))
864	return rcRet;
865	return rcStream;
866	}
867
868
869	/**
870	* Deals with comments in SQL files.
871	*
872	* @returns VBox status code / callback return code.
873	* @param pIn The stream to parse.
874	* @param pfnCallback The callback.
875	* @param pvUser The user parameter for the callback.
876	*/
877	static int enumerateSqlComments(PSCMSTREAM pIn, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
878	{
879	int rcRet = VINF_SUCCESS;
880	uint32_t iLine = 0;
881	SCMEOL enmEol;
882	size_t cchLine;
883	const char *pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
884	while (pchLine != NULL)
885	{
886	/*
887	* Skip leading blanks and check for '--'.
888	*/
889	size_t off = 0;
890	while (off + 3 < cchLine && RT_C_IS_SPACE(pchLine[off]))
891	off++;
892	if ( cchLine < 2
893	\|\| pchLine[0] != '-'
894	\|\| pchLine[1] != '-')
895	{
896	iLine++;
897	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
898	}
899	else
900	{
901	int rc = handleLineComment(pIn, isSqlComment, pfnCallback, pvUser,
902	&pchLine, &cchLine, &enmEol, &iLine, &off);
903	if (RT_FAILURE(rc))
904	return rc;
905	if (rcRet == VINF_SUCCESS)
906	rcRet = rc;
907	}
908	}
909
910	int rcStream = ScmStreamGetStatus(pIn);
911	if (RT_SUCCESS(rcStream))
912	return rcRet;
913	return rcStream;
914	}
915
916
917	/**
918	* Deals with simple line comments.
919	*
920	* @returns VBox status code / callback return code.
921	* @param pIn The stream to parse.
922	* @param chStart The start of comment character.
923	* @param pfnIsComment Comment tester function.
924	* @param pfnCallback The callback.
925	* @param pvUser The user parameter for the callback.
926	*/
927	static int enumerateSimpleLineComments(PSCMSTREAM pIn, char chStart, PFNISCOMMENT pfnIsComment,
928	PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
929	{
930	int rcRet = VINF_SUCCESS;
931	uint32_t iLine = 0;
932	SCMEOL enmEol;
933	size_t cchLine;
934	const char *pchLine;
935	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
936	{
937	size_t off = 0;
938	while (off < cchLine)
939	{
940	char ch = pchLine[off++];
941	if (ch != chStart)
942	{ /* not interesting */ }
943	else
944	{
945	off -= 1;
946	int rc = handleLineComment(pIn, pfnIsComment, pfnCallback, pvUser,
947	&pchLine, &cchLine, &enmEol, &iLine, &off);
948	if (RT_FAILURE(rc))
949	return rc;
950	if (rcRet == VINF_SUCCESS)
951	rcRet = rc;
952
953	if (!pchLine)
954	break;
955	}
956	} /* for each character in the line */
957
958	iLine++;
959	} /* for each line in the stream */
960
961	int rcStream = ScmStreamGetStatus(pIn);
962	if (RT_SUCCESS(rcStream))
963	return rcRet;
964	return rcStream;
965	}
966
967
968	/**
969	* Enumerates the comments in the given stream, calling @a pfnCallback for each.
970	*
971	* @returns IPRT status code.
972	* @param pIn The stream to parse.
973	* @param enmCommentStyle The comment style of the source stream.
974	* @param pfnCallback The function to call.
975	* @param pvUser User argument to the callback.
976	*/
977	int ScmEnumerateComments(PSCMSTREAM pIn, SCMCOMMENTSTYLE enmCommentStyle, PFNSCMCOMMENTENUMERATOR pfnCallback, void *pvUser)
978	{
979	switch (enmCommentStyle)
980	{
981	case kScmCommentStyle_C:
982	return enumerateCStyleComments(pIn, pfnCallback, pvUser);
983
984	case kScmCommentStyle_Python:
985	return enumeratePythonComments(pIn, pfnCallback, pvUser);
986
987	case kScmCommentStyle_Semicolon:
988	return enumerateSimpleLineComments(pIn, ';', isSemicolonComment, pfnCallback, pvUser);
989
990	case kScmCommentStyle_Hash:
991	return enumerateSimpleLineComments(pIn, '#', isHashComment, pfnCallback, pvUser);
992
993	case kScmCommentStyle_Rem_Upper:
994	case kScmCommentStyle_Rem_Lower:
995	case kScmCommentStyle_Rem_Camel:
996	return enumerateBatchComments(pIn, pfnCallback, pvUser);
997
998	case kScmCommentStyle_Sql:
999	return enumerateSqlComments(pIn, pfnCallback, pvUser);
1000
1001	case kScmCommentStyle_Tick:
1002	return enumerateSimpleLineComments(pIn, '\'', isTickComment, pfnCallback, pvUser);
1003
1004	default:
1005	AssertFailedReturn(VERR_INVALID_PARAMETER);
1006	}
1007	}
1008

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

source: vbox/trunk/src/bldprogs/scmparser.cpp@ 74856

Download in other formats: