scmrw.cpp@ 96445

Last change on this file since 96445 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 143.3 KB

Line
1	/* $Id: scmrw.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* IPRT Testcase / Tool - Source Code Massager.
4	*/
5
6	/*
7	* Copyright (C) 2010-2022 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <iprt/assert.h>
33	#include <iprt/ctype.h>
34	#include <iprt/dir.h>
35	#include <iprt/env.h>
36	#include <iprt/file.h>
37	#include <iprt/err.h>
38	#include <iprt/getopt.h>
39	#include <iprt/initterm.h>
40	#include <iprt/mem.h>
41	#include <iprt/message.h>
42	#include <iprt/param.h>
43	#include <iprt/path.h>
44	#include <iprt/process.h>
45	#include <iprt/stream.h>
46	#include <iprt/string.h>
47
48	#include "scm.h"
49
50
51	/*********************************************************************************************************************************
52	* Structures and Typedefs *
53	*********************************************************************************************************************************/
54	/** License types. */
55	typedef enum SCMLICENSETYPE
56	{
57	kScmLicenseType_Invalid = 0,
58	kScmLicenseType_OseGpl,
59	kScmLicenseType_OseDualGplCddl,
60	kScmLicenseType_OseCddl,
61	kScmLicenseType_VBoxLgpl,
62	kScmLicenseType_Mit,
63	kScmLicenseType_Confidential
64	} SCMLICENSETYPE;
65
66	/** A license. */
67	typedef struct SCMLICENSETEXT
68	{
69	/** The license type. */
70	SCMLICENSETYPE enmType;
71	/** The license option. */
72	SCMLICENSE enmOpt;
73	/** The license text. */
74	const char *psz;
75	/** The license text length. */
76	size_t cch;
77	} SCMLICENSETEXT;
78	/** Pointer to a license. */
79	typedef SCMLICENSETEXT const *PCSCMLICENSETEXT;
80
81	/**
82	* Copyright + license rewriter state.
83	*/
84	typedef struct SCMCOPYRIGHTINFO
85	{
86	/** State. */
87	PSCMRWSTATE pState; /*< input /
88	/** The comment style (neede for C/C++). */
89	SCMCOMMENTSTYLE enmCommentStyle; /*< input /
90
91	/** Number of comments we've parsed. */
92	uint32_t cComments;
93
94	/** Copy of the contributed-by line if present. */
95	char *pszContributedBy;
96
97	/** @name Common info
98	* @{ */
99	uint32_t iLineComment;
100	uint32_t cLinesComment; /*< This excludes any external license lines. /
101	/** @} */
102
103	/** @name Copyright info
104	* @{ */
105	uint32_t iLineCopyright;
106	uint32_t uFirstYear;
107	uint32_t uLastYear;
108	bool fWellFormedCopyright;
109	bool fUpToDateCopyright;
110	/** @} */
111
112	/** @name License info
113	* @{ */
114	bool fOpenSource; /*< input /
115	PCSCMLICENSETEXT pExpectedLicense; /*< input /
116	PCSCMLICENSETEXT paLicenses; /*< input /
117	SCMLICENSE enmLicenceOpt; /*< input /
118	uint32_t iLineLicense;
119	uint32_t cLinesLicense;
120	PCSCMLICENSETEXT pCurrentLicense;
121	bool fIsCorrectLicense;
122	bool fWellFormedLicense;
123	bool fExternalLicense;
124	/** @} */
125
126	/** @name LGPL licence notice and disclaimer info
127	* @{ */
128	/** Wheter to check for LGPL license notices and disclaimers. */
129	bool fCheckforLgpl;
130	/** The approximate line we found the (first) LGPL licence notice on. */
131	uint32_t iLineLgplNotice;
132	/** The line number after the LGPL notice comment. */
133	uint32_t iLineAfterLgplComment;
134	/** The LGPL disclaimer line. */
135	uint32_t iLineLgplDisclaimer;
136	/** @} */
137
138	} SCMCOPYRIGHTINFO;
139	typedef SCMCOPYRIGHTINFO *PSCMCOPYRIGHTINFO;
140
141
142	/*********************************************************************************************************************************
143	* Global Variables *
144	*********************************************************************************************************************************/
145	/** --license-ose-gpl */
146	static const char g_szVBoxOseGpl[] =
147	"This file is part of VirtualBox base platform packages, as\n"
148	"available from https://www.virtualbox.org.\n"
149	"\n"
150	"This program is free software; you can redistribute it and/or\n"
151	"modify it under the terms of the GNU General Public License\n"
152	"as published by the Free Software Foundation, in version 3 of the\n"
153	"License.\n"
154	"\n"
155	"This program is distributed in the hope that it will be useful, but\n"
156	"WITHOUT ANY WARRANTY; without even the implied warranty of\n"
157	"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
158	"General Public License for more details.\n"
159	"\n"
160	"You should have received a copy of the GNU General Public License\n"
161	"along with this program; if not, see <https://www.gnu.org/licenses>.\n"
162	"\n"
163	"SPDX-License-Identifier: GPL-3.0-only\n";
164
165	static const char g_szVBoxOseOldGpl2[] =
166	"This file is part of VirtualBox Open Source Edition (OSE), as\n"
167	"available from http://www.virtualbox.org. This file is free software;\n"
168	"you can redistribute it and/or modify it under the terms of the GNU\n"
169	"General Public License (GPL) as published by the Free Software\n"
170	"Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
171	"VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
172	"hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n";
173
174	/** --license-ose-dual */
175	static const char g_szVBoxOseDualGplCddl[] =
176	"This file is part of VirtualBox base platform packages, as\n"
177	"available from https://www.virtualbox.org.\n"
178	"\n"
179	"This program is free software; you can redistribute it and/or\n"
180	"modify it under the terms of the GNU General Public License\n"
181	"as published by the Free Software Foundation, in version 3 of the\n"
182	"License.\n"
183	"\n"
184	"This program is distributed in the hope that it will be useful, but\n"
185	"WITHOUT ANY WARRANTY; without even the implied warranty of\n"
186	"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
187	"General Public License for more details.\n"
188	"\n"
189	"You should have received a copy of the GNU General Public License\n"
190	"along with this program; if not, see <https://www.gnu.org/licenses>.\n"
191	"\n"
192	"The contents of this file may alternatively be used under the terms\n"
193	"of the Common Development and Distribution License Version 1.0\n"
194	"(CDDL), a copy of it is provided in the \"COPYING.CDDL\" file included\n"
195	"in the VirtualBox distribution, in which case the provisions of the\n"
196	"CDDL are applicable instead of those of the GPL.\n"
197	"\n"
198	"You may elect to license modified versions of this file under the\n"
199	"terms and conditions of either the GPL or the CDDL or both.\n"
200	"\n"
201	"SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0\n";
202
203	static const char g_szVBoxOseOldDualGpl2Cddl[] =
204	"This file is part of VirtualBox Open Source Edition (OSE), as\n"
205	"available from http://www.virtualbox.org. This file is free software;\n"
206	"you can redistribute it and/or modify it under the terms of the GNU\n"
207	"General Public License (GPL) as published by the Free Software\n"
208	"Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
209	"VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
210	"hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n"
211	"\n"
212	"The contents of this file may alternatively be used under the terms\n"
213	"of the Common Development and Distribution License Version 1.0\n"
214	"(CDDL) only, as it comes in the \"COPYING.CDDL\" file of the\n"
215	"VirtualBox OSE distribution, in which case the provisions of the\n"
216	"CDDL are applicable instead of those of the GPL.\n"
217	"\n"
218	"You may elect to license modified versions of this file under the\n"
219	"terms and conditions of either the GPL or the CDDL or both.\n";
220
221	/** --license-ose-cddl */
222	static const char g_szVBoxOseCddl[] =
223	"This file is part of VirtualBox base platform packages, as\n"
224	"available from http://www.virtualbox.org.\n"
225	"\n"
226	"The contents of this file are subject to the terms of the Common\n"
227	"Development and Distribution License Version 1.0 (CDDL) only, as it\n"
228	"comes in the \"COPYING.CDDL\" file of the VirtualBox distribution.\n"
229	"\n"
230	"SPDX-License-Identifier: CDDL-1.0\n";
231
232	static const char g_szVBoxOseOldCddl[] =
233	"This file is part of VirtualBox Open Source Edition (OSE), as\n"
234	"available from http://www.virtualbox.org. This file is free software;\n"
235	"you can redistribute it and/or modify it under the terms of the Common\n"
236	"Development and Distribution License Version 1.0 (CDDL) only, as it\n"
237	"comes in the \"COPYING.CDDL\" file of the VirtualBox OSE distribution.\n"
238	"VirtualBox OSE is distributed in the hope that it will be useful, but\n"
239	"WITHOUT ANY WARRANTY of any kind.\n";
240
241	/** --license-lgpl */
242	static const char g_szVBoxLgpl[] =
243	"This file is part of a free software library; you can redistribute\n"
244	"it and/or modify it under the terms of the GNU Lesser General\n"
245	"Public License version 2.1 as published by the Free Software\n"
246	"Foundation and shipped in the \"COPYING.LIB\" file with this library.\n"
247	"The library is distributed in the hope that it will be useful,\n"
248	"but WITHOUT ANY WARRANTY of any kind.\n"
249	"\n"
250	"Oracle LGPL Disclaimer: For the avoidance of doubt, except that if\n"
251	"any license choice other than GPL or LGPL is available it will\n"
252	"apply instead, Oracle elects to use only the Lesser General Public\n"
253	"License version 2.1 (LGPLv2) at this time for any software where\n"
254	"a choice of LGPL license versions is made available with the\n"
255	"language indicating that LGPLv2 or any later version may be used,\n"
256	"or where a choice of which version of the LGPL is applied is\n"
257	"otherwise unspecified.\n"
258	"\n"
259	"SPDX-License-Identifier: LGPL-2.1-only\n";
260
261	/** --license-mit
262	* @note This isn't detectable as VirtualBox or Oracle specific.
263	*/
264	static const char g_szMit[] =
265	"Permission is hereby granted, free of charge, to any person\n"
266	"obtaining a copy of this software and associated documentation\n"
267	"files (the \"Software\"), to deal in the Software without\n"
268	"restriction, including without limitation the rights to use,\n"
269	"copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
270	"copies of the Software, and to permit persons to whom the\n"
271	"Software is furnished to do so, subject to the following\n"
272	"conditions:\n"
273	"\n"
274	"The above copyright notice and this permission notice shall be\n"
275	"included in all copies or substantial portions of the Software.\n"
276	"\n"
277	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n"
278	"EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n"
279	"OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n"
280	"NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n"
281	"HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n"
282	"WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
283	"FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
284	"OTHER DEALINGS IN THE SOFTWARE.\n";
285
286	/** --license-mit, alternative wording \#1.
287	* @note This differes from g_szMit in "AUTHORS OR COPYRIGHT HOLDERS" is written
288	* "COPYRIGHT HOLDER(S) OR AUTHOR(S)". Its layout is wider, so it is a
289	* couple of lines shorter. */
290	static const char g_szMitAlt1[] =
291	"Permission is hereby granted, free of charge, to any person obtaining a\n"
292	"copy of this software and associated documentation files (the \"Software\"),\n"
293	"to deal in the Software without restriction, including without limitation\n"
294	"the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
295	"and/or sell copies of the Software, and to permit persons to whom the\n"
296	"Software is furnished to do so, subject to the following conditions:\n"
297	"\n"
298	"The above copyright notice and this permission notice shall be included in\n"
299	"all copies or substantial portions of the Software.\n"
300	"\n"
301	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
302	"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
303	"FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n"
304	"THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR\n"
305	"OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n"
306	"ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
307	"OTHER DEALINGS IN THE SOFTWARE.\n";
308
309	/** --license-mit, alternative wording \#2.
310	* @note This differes from g_szMit in that "AUTHORS OR COPYRIGHT HOLDERS" is
311	* replaced with "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS".
312	* Its layout is wider, so it is a couple of lines shorter. */
313	static const char g_szMitAlt2[] =
314	"Permission is hereby granted, free of charge, to any person obtaining a\n"
315	"copy of this software and associated documentation files (the \"Software\"),\n"
316	"to deal in the Software without restriction, including without limitation\n"
317	"the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
318	"and/or sell copies of the Software, and to permit persons to whom the\n"
319	"Software is furnished to do so, subject to the following conditions:\n"
320	"\n"
321	"The above copyright notice and this permission notice shall be included in\n"
322	"all copies or substantial portions of the Software.\n"
323	"\n"
324	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
325	"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
326	"FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
327	"THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
328	"DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
329	"OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
330	"USE OR OTHER DEALINGS IN THE SOFTWARE.\n";
331
332	/** --license-mit, alternative wording \#3.
333	* @note This differes from g_szMitAlt2 in that the second and third sections
334	* have been switch. */
335	static const char g_szMitAlt3[] =
336	"Permission is hereby granted, free of charge, to any person obtaining a\n"
337	"copy of this software and associated documentation files (the \"Software\"),\n"
338	"to deal in the Software without restriction, including without limitation\n"
339	"the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
340	"and/or sell copies of the Software, and to permit persons to whom the\n"
341	"Software is furnished to do so, subject to the following conditions:\n"
342	"\n"
343	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
344	"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
345	"FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
346	"THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
347	"DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
348	"OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
349	"USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
350	"\n"
351	"The above copyright notice and this permission notice shall be included in\n"
352	"all copies or substantial portions of the Software.\n";
353
354	/** --license-(based-on)mit, alternative wording \#4.
355	* @note This differs from g_szMitAlt2 in injecting "(including the next
356	* paragraph)". */
357	static const char g_szMitAlt4[] =
358	"Permission is hereby granted, free of charge, to any person obtaining a\n"
359	"copy of this software and associated documentation files (the \"Software\"),\n"
360	"to deal in the Software without restriction, including without limitation\n"
361	"the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
362	"and/or sell copies of the Software, and to permit persons to whom the\n"
363	"Software is furnished to do so, subject to the following conditions:\n"
364	"\n"
365	"The above copyright notice and this permission notice (including the next\n"
366	"paragraph) shall be included in all copies or substantial portions of the\n"
367	"Software.\n"
368	"\n"
369	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
370	"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
371	"FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n"
372	"THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n"
373	"LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
374	"FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n"
375	"DEALINGS IN THE SOFTWARE.\n";
376
377	/** --license-(based-on)mit, alternative wording \#5.
378	* @note This differs from g_szMitAlt3 in using "sub license" instead of
379	* "sublicense" and adding an illogical "(including the next
380	* paragraph)" remark to the final paragraph. (vbox_ttm.c) */
381	static const char g_szMitAlt5[] =
382	"Permission is hereby granted, free of charge, to any person obtaining a\n"
383	"copy of this software and associated documentation files (the\n"
384	"\"Software\"), to deal in the Software without restriction, including\n"
385	"without limitation the rights to use, copy, modify, merge, publish,\n"
386	"distribute, sub license, and/or sell copies of the Software, and to\n"
387	"permit persons to whom the Software is furnished to do so, subject to\n"
388	"the following conditions:\n"
389	"\n"
390	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
391	"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
392	"FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
393	"THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
394	"DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
395	"OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
396	"USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
397	"\n"
398	"The above copyright notice and this permission notice (including the\n"
399	"next paragraph) shall be included in all copies or substantial portions\n"
400	"of the Software.\n";
401
402	/** Oracle confidential. */
403	static const char g_szOracleConfidential[] =
404	"Oracle Corporation confidential\n";
405
406	/** Oracle confidential, old style. */
407	static const char g_szOracleConfidentialOld[] =
408	"Oracle Corporation confidential\n"
409	"All rights reserved\n";
410
411	/** Licenses to detect when --license-mit isn't used. */
412	static const SCMLICENSETEXT g_aLicenses[] =
413	{
414	{ kScmLicenseType_OseGpl, kScmLicense_OseGpl, RT_STR_TUPLE(g_szVBoxOseGpl)},
415	{ kScmLicenseType_OseGpl, kScmLicense_OseGpl, RT_STR_TUPLE(g_szVBoxOseOldGpl2)},
416	{ kScmLicenseType_OseDualGplCddl, kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
417	{ kScmLicenseType_OseDualGplCddl, kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseOldDualGpl2Cddl) },
418	{ kScmLicenseType_OseCddl, kScmLicense_OseCddl, RT_STR_TUPLE(g_szVBoxOseCddl) },
419	{ kScmLicenseType_OseCddl, kScmLicense_OseCddl, RT_STR_TUPLE(g_szVBoxOseOldCddl) },
420	{ kScmLicenseType_VBoxLgpl, kScmLicense_Lgpl, RT_STR_TUPLE(g_szVBoxLgpl)},
421	{ kScmLicenseType_Confidential, kScmLicense_End, RT_STR_TUPLE(g_szOracleConfidential) },
422	{ kScmLicenseType_Confidential, kScmLicense_End, RT_STR_TUPLE(g_szOracleConfidentialOld) },
423	{ kScmLicenseType_Invalid, kScmLicense_End, NULL, 0 },
424	};
425
426	/** Licenses to detect when --license-mit or --license-based-on-mit are used. */
427	static const SCMLICENSETEXT g_aLicensesWithMit[] =
428	{
429	{ kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMit) },
430	{ kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt1) },
431	{ kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt2) },
432	{ kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt3) },
433	{ kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt4) },
434	{ kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt5) },
435	{ kScmLicenseType_OseGpl, kScmLicense_OseGpl, RT_STR_TUPLE(g_szVBoxOseGpl)},
436	{ kScmLicenseType_OseGpl, kScmLicense_OseGpl, RT_STR_TUPLE(g_szVBoxOseOldGpl2)},
437	{ kScmLicenseType_OseDualGplCddl, kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
438	{ kScmLicenseType_OseDualGplCddl, kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseOldDualGpl2Cddl) },
439	{ kScmLicenseType_VBoxLgpl, kScmLicense_Lgpl, RT_STR_TUPLE(g_szVBoxLgpl)},
440	{ kScmLicenseType_Confidential, kScmLicense_End, RT_STR_TUPLE(g_szOracleConfidential) },
441	{ kScmLicenseType_Confidential, kScmLicense_End, RT_STR_TUPLE(g_szOracleConfidentialOld) },
442	{ kScmLicenseType_Invalid, kScmLicense_End, NULL, 0 },
443	};
444
445	/** Copyright holder. */
446	static const char g_szCopyrightHolder[] = "Oracle and/or its affiliates.";
447
448	/** Old copyright holder. */
449	static const char g_szOldCopyrightHolder[] = "Oracle Corporation";
450
451	/** LGPL disclaimer. */
452	static const char g_szLgplDisclaimer[] =
453	"Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice\n"
454	"other than GPL or LGPL is available it will apply instead, Oracle elects to use only\n"
455	"the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where\n"
456	"a choice of LGPL license versions is made available with the language indicating\n"
457	"that LGPLv2 or any later version may be used, or where a choice of which version\n"
458	"of the LGPL is applied is otherwise unspecified.\n";
459
460	/** Copyright+license comment start for each SCMCOMMENTSTYLE. */
461	static RTSTRTUPLE const g_aCopyrightCommentStart[] =
462	{
463	{ RT_STR_TUPLE("<invalid> ") },
464	{ RT_STR_TUPLE("/*") },
465	{ RT_STR_TUPLE("#") },
466	{ RT_STR_TUPLE("\"\"\"") },
467	{ RT_STR_TUPLE(";") },
468	{ RT_STR_TUPLE("REM") },
469	{ RT_STR_TUPLE("rem") },
470	{ RT_STR_TUPLE("Rem") },
471	{ RT_STR_TUPLE("--") },
472	{ RT_STR_TUPLE("'") },
473	{ RT_STR_TUPLE("<!--") },
474	{ RT_STR_TUPLE("<end>") },
475	};
476
477	/** Copyright+license line prefix for each SCMCOMMENTSTYLE. */
478	static RTSTRTUPLE const g_aCopyrightCommentPrefix[] =
479	{
480	{ RT_STR_TUPLE("<invalid> ") },
481	{ RT_STR_TUPLE(" * ") },
482	{ RT_STR_TUPLE("# ") },
483	{ RT_STR_TUPLE("") },
484	{ RT_STR_TUPLE("; ") },
485	{ RT_STR_TUPLE("REM ") },
486	{ RT_STR_TUPLE("rem ") },
487	{ RT_STR_TUPLE("Rem ") },
488	{ RT_STR_TUPLE("-- ") },
489	{ RT_STR_TUPLE("' ") },
490	{ RT_STR_TUPLE(" ") },
491	{ RT_STR_TUPLE("<end>") },
492	};
493
494	/** Copyright+license empty line for each SCMCOMMENTSTYLE. */
495	static RTSTRTUPLE const g_aCopyrightCommentEmpty[] =
496	{
497	{ RT_STR_TUPLE("<invalid>") },
498	{ RT_STR_TUPLE(" *") },
499	{ RT_STR_TUPLE("#") },
500	{ RT_STR_TUPLE("") },
501	{ RT_STR_TUPLE(";") },
502	{ RT_STR_TUPLE("REM") },
503	{ RT_STR_TUPLE("rem") },
504	{ RT_STR_TUPLE("Rem") },
505	{ RT_STR_TUPLE("--") },
506	{ RT_STR_TUPLE("'") },
507	{ RT_STR_TUPLE("") },
508	{ RT_STR_TUPLE("<end>") },
509	};
510
511	/** Copyright+license end of comment for each SCMCOMMENTSTYLE. */
512	static RTSTRTUPLE const g_aCopyrightCommentEnd[] =
513	{
514	{ RT_STR_TUPLE("<invalid> ") },
515	{ RT_STR_TUPLE(" */") },
516	{ RT_STR_TUPLE("#") },
517	{ RT_STR_TUPLE("\"\"\"") },
518	{ RT_STR_TUPLE(";") },
519	{ RT_STR_TUPLE("REM") },
520	{ RT_STR_TUPLE("rem") },
521	{ RT_STR_TUPLE("Rem") },
522	{ RT_STR_TUPLE("--") },
523	{ RT_STR_TUPLE("'") },
524	{ RT_STR_TUPLE("-->") },
525	{ RT_STR_TUPLE("<end>") },
526	};
527
528
529	/**
530	* Figures out the predominant casing of the "REM" keyword in a batch file.
531	*
532	* @returns Predominant comment style.
533	* @param pIn The file to scan. Will be rewound.
534	*/
535	static SCMCOMMENTSTYLE determineBatchFileCommentStyle(PSCMSTREAM pIn)
536	{
537	/*
538	* Figure out whether it's using upper or lower case REM comments before
539	* doing the work.
540	*/
541	uint32_t cUpper = 0;
542	uint32_t cLower = 0;
543	uint32_t cCamel = 0;
544	SCMEOL enmEol;
545	size_t cchLine;
546	const char *pchLine;
547	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
548	{
549	while ( cchLine > 2
550	&& RT_C_IS_SPACE(*pchLine))
551	{
552	pchLine++;
553	cchLine--;
554	}
555	if ( ( cchLine > 3
556	&& RT_C_IS_SPACE(pchLine[2]))
557	\|\| cchLine == 3)
558	{
559	if ( pchLine[0] == 'R'
560	&& pchLine[1] == 'E'
561	&& pchLine[2] == 'M')
562	cUpper++;
563	else if ( pchLine[0] == 'r'
564	&& pchLine[1] == 'e'
565	&& pchLine[2] == 'm')
566	cLower++;
567	else if ( pchLine[0] == 'R'
568	&& pchLine[1] == 'e'
569	&& pchLine[2] == 'm')
570	cCamel++;
571	}
572	}
573
574	ScmStreamRewindForReading(pIn);
575
576	if (cLower >= cUpper && cLower >= cCamel)
577	return kScmCommentStyle_Rem_Lower;
578	if (cCamel >= cLower && cCamel >= cUpper)
579	return kScmCommentStyle_Rem_Camel;
580	return kScmCommentStyle_Rem_Upper;
581	}
582
583
584	/**
585	* Worker for isBlankLine.
586	*
587	* @returns true if blank, false if not.
588	* @param pchLine Pointer to the start of the line.
589	* @param cchLine The (encoded) length of the line, excluding EOL char.
590	*/
591	static bool isBlankLineSlow(const char *pchLine, size_t cchLine)
592	{
593	/*
594	* From the end, more likely to hit a non-blank char there.
595	*/
596	while (cchLine-- > 0)
597	if (!RT_C_IS_BLANK(pchLine[cchLine]))
598	return false;
599	return true;
600	}
601
602	/**
603	* Helper for checking whether a line is blank.
604	*
605	* @returns true if blank, false if not.
606	* @param pchLine Pointer to the start of the line.
607	* @param cchLine The (encoded) length of the line, excluding EOL char.
608	*/
609	DECLINLINE(bool) isBlankLine(const char *pchLine, size_t cchLine)
610	{
611	if (cchLine == 0)
612	return true;
613	/*
614	* We're more likely to fine a non-space char at the end of the line than
615	* at the start, due to source code indentation.
616	*/
617	if (pchLine[cchLine - 1])
618	return false;
619
620	/*
621	* Don't bother inlining loop code.
622	*/
623	return isBlankLineSlow(pchLine, cchLine);
624	}
625
626
627	/**
628	* Checks if there are @a cch blanks at @a pch.
629	*
630	* @returns true if span of @a cch blanks, false if not.
631	* @param pch The start of the span to check.
632	* @param cch The length of the span.
633	*/
634	DECLINLINE(bool) isSpanOfBlanks(const char *pch, size_t cch)
635	{
636	while (cch-- > 0)
637	{
638	char const ch = *pch++;
639	if (!RT_C_IS_BLANK(ch))
640	return false;
641	}
642	return true;
643	}
644
645
646	/**
647	* Strip trailing blanks (space & tab).
648	*
649	* @returns True if modified, false if not.
650	* @param pIn The input stream.
651	* @param pOut The output stream.
652	* @param pSettings The settings.
653	*/
654	bool rewrite_StripTrailingBlanks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
655	{
656	if (!pSettings->fStripTrailingBlanks)
657	return false;
658
659	bool fModified = false;
660	SCMEOL enmEol;
661	size_t cchLine;
662	const char *pchLine;
663	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
664	{
665	int rc;
666	if ( cchLine == 0
667	\|\| !RT_C_IS_BLANK(pchLine[cchLine - 1]) )
668	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
669	else
670	{
671	cchLine--;
672	while (cchLine > 0 && RT_C_IS_BLANK(pchLine[cchLine - 1]))
673	cchLine--;
674	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
675	fModified = true;
676	}
677	if (RT_FAILURE(rc))
678	return false;
679	}
680	if (fModified)
681	ScmVerbose(pState, 2, " * Stripped trailing blanks\n");
682	return fModified;
683	}
684
685	/**
686	* Expand tabs.
687	*
688	* @returns True if modified, false if not.
689	* @param pIn The input stream.
690	* @param pOut The output stream.
691	* @param pSettings The settings.
692	*/
693	bool rewrite_ExpandTabs(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
694	{
695	if (!pSettings->fConvertTabs)
696	return false;
697
698	size_t const cchTab = pSettings->cchTab;
699	bool fModified = false;
700	SCMEOL enmEol;
701	size_t cchLine;
702	const char *pchLine;
703	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
704	{
705	int rc;
706	const char pchTab = (const char )memchr(pchLine, '\t', cchLine);
707	if (!pchTab)
708	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
709	else
710	{
711	size_t offTab = 0;
712	const char *pchChunk = pchLine;
713	for (;;)
714	{
715	size_t cchChunk = pchTab - pchChunk;
716	offTab += cchChunk;
717	ScmStreamWrite(pOut, pchChunk, cchChunk);
718
719	size_t cchToTab = cchTab - offTab % cchTab;
720	ScmStreamWrite(pOut, g_szTabSpaces, cchToTab);
721	offTab += cchToTab;
722
723	pchChunk = pchTab + 1;
724	size_t cchLeft = cchLine - (pchChunk - pchLine);
725	pchTab = (const char *)memchr(pchChunk, '\t', cchLeft);
726	if (!pchTab)
727	{
728	rc = ScmStreamPutLine(pOut, pchChunk, cchLeft, enmEol);
729	break;
730	}
731	}
732
733	fModified = true;
734	}
735	if (RT_FAILURE(rc))
736	return false;
737	}
738	if (fModified)
739	ScmVerbose(pState, 2, " * Expanded tabs\n");
740	return fModified;
741	}
742
743	/**
744	* Worker for rewrite_ForceNativeEol, rewrite_ForceLF and rewrite_ForceCRLF.
745	*
746	* @returns true if modifications were made, false if not.
747	* @param pIn The input stream.
748	* @param pOut The output stream.
749	* @param pSettings The settings.
750	* @param enmDesiredEol The desired end of line indicator type.
751	* @param pszDesiredSvnEol The desired svn:eol-style.
752	*/
753	static bool rewrite_ForceEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
754	SCMEOL enmDesiredEol, const char *pszDesiredSvnEol)
755	{
756	if (!pSettings->fConvertEol)
757	return false;
758
759	bool fModified = false;
760	SCMEOL enmEol;
761	size_t cchLine;
762	const char *pchLine;
763	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
764	{
765	if ( enmEol != enmDesiredEol
766	&& enmEol != SCMEOL_NONE)
767	{
768	fModified = true;
769	enmEol = enmDesiredEol;
770	}
771	int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
772	if (RT_FAILURE(rc))
773	return false;
774	}
775	if (fModified)
776	ScmVerbose(pState, 2, " * Converted EOL markers\n");
777
778	/* Check svn:eol-style if appropriate */
779	if ( pSettings->fSetSvnEol
780	&& ScmSvnIsInWorkingCopy(pState))
781	{
782	char *pszEol;
783	int rc = ScmSvnQueryProperty(pState, "svn:eol-style", &pszEol);
784	if ( (RT_SUCCESS(rc) && strcmp(pszEol, pszDesiredSvnEol))
785	\|\| rc == VERR_NOT_FOUND)
786	{
787	if (rc == VERR_NOT_FOUND)
788	ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (missing)\n", pszDesiredSvnEol);
789	else
790	ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (was: %s)\n", pszDesiredSvnEol, pszEol);
791	int rc2 = ScmSvnSetProperty(pState, "svn:eol-style", pszDesiredSvnEol);
792	if (RT_FAILURE(rc2))
793	ScmError(pState, rc2, "ScmSvnSetProperty: %Rrc\n", rc2);
794	}
795	if (RT_SUCCESS(rc))
796	RTStrFree(pszEol);
797	}
798
799	/** @todo also check the subversion svn:eol-style state! */
800	return fModified;
801	}
802
803	/**
804	* Force native end of line indicator.
805	*
806	* @returns true if modifications were made, false if not.
807	* @param pIn The input stream.
808	* @param pOut The output stream.
809	* @param pSettings The settings.
810	*/
811	bool rewrite_ForceNativeEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
812	{
813	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
814	return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "native");
815	#else
816	return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF, "native");
817	#endif
818	}
819
820	/**
821	* Force the stream to use LF as the end of line indicator.
822	*
823	* @returns true if modifications were made, false if not.
824	* @param pIn The input stream.
825	* @param pOut The output stream.
826	* @param pSettings The settings.
827	*/
828	bool rewrite_ForceLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
829	{
830	return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF, "LF");
831	}
832
833	/**
834	* Force the stream to use CRLF as the end of line indicator.
835	*
836	* @returns true if modifications were made, false if not.
837	* @param pIn The input stream.
838	* @param pOut The output stream.
839	* @param pSettings The settings.
840	*/
841	bool rewrite_ForceCRLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
842	{
843	return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "CRLF");
844	}
845
846	/**
847	* Strip trailing blank lines and/or make sure there is exactly one blank line
848	* at the end of the file.
849	*
850	* @returns true if modifications were made, false if not.
851	* @param pIn The input stream.
852	* @param pOut The output stream.
853	* @param pSettings The settings.
854	*
855	* @remarks ASSUMES trailing white space has been removed already.
856	*/
857	bool rewrite_AdjustTrailingLines(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
858	{
859	if ( !pSettings->fStripTrailingLines
860	&& !pSettings->fForceTrailingLine
861	&& !pSettings->fForceFinalEol)
862	return false;
863
864	size_t const cLines = ScmStreamCountLines(pIn);
865
866	/* Empty files remains empty. */
867	if (cLines <= 1)
868	return false;
869
870	/* Figure out if we need to adjust the number of lines or not. */
871	size_t cLinesNew = cLines;
872
873	if ( pSettings->fStripTrailingLines
874	&& ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
875	{
876	while ( cLinesNew > 1
877	&& ScmStreamIsWhiteLine(pIn, cLinesNew - 2))
878	cLinesNew--;
879	}
880
881	if ( pSettings->fForceTrailingLine
882	&& !ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
883	cLinesNew++;
884
885	bool fFixMissingEol = pSettings->fForceFinalEol
886	&& ScmStreamGetEolByLine(pIn, cLinesNew - 1) == SCMEOL_NONE;
887
888	if ( !fFixMissingEol
889	&& cLines == cLinesNew)
890	return false;
891
892	/* Copy the number of lines we've arrived at. */
893	ScmStreamRewindForReading(pIn);
894
895	size_t cCopied = RT_MIN(cLinesNew, cLines);
896	ScmStreamCopyLines(pOut, pIn, cCopied);
897
898	if (cCopied != cLinesNew)
899	{
900	while (cCopied++ < cLinesNew)
901	ScmStreamPutLine(pOut, "", 0, ScmStreamGetEol(pIn));
902	}
903	/* Fix missing EOL if required. */
904	else if (fFixMissingEol)
905	{
906	if (ScmStreamGetEol(pIn) == SCMEOL_LF)
907	ScmStreamWrite(pOut, "\n", 1);
908	else
909	ScmStreamWrite(pOut, "\r\n", 2);
910	}
911
912	ScmVerbose(pState, 2, " * Adjusted trailing blank lines\n");
913	return true;
914	}
915
916	/**
917	* Make sure there is no svn:executable property on the current file.
918	*
919	* @returns false - the state carries these kinds of changes.
920	* @param pState The rewriter state.
921	* @param pIn The input stream.
922	* @param pOut The output stream.
923	* @param pSettings The settings.
924	*/
925	bool rewrite_SvnNoExecutable(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
926	{
927	RT_NOREF2(pIn, pOut);
928	if ( !pSettings->fSetSvnExecutable
929	\|\| !ScmSvnIsInWorkingCopy(pState))
930	return false;
931
932	int rc = ScmSvnQueryProperty(pState, "svn:executable", NULL);
933	if (RT_SUCCESS(rc))
934	{
935	ScmVerbose(pState, 2, " * removing svn:executable\n");
936	rc = ScmSvnDelProperty(pState, "svn:executable");
937	if (RT_FAILURE(rc))
938	ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
939	}
940	return false;
941	}
942
943	/**
944	* Make sure there is no svn:keywords property on the current file.
945	*
946	* @returns false - the state carries these kinds of changes.
947	* @param pState The rewriter state.
948	* @param pIn The input stream.
949	* @param pOut The output stream.
950	* @param pSettings The settings.
951	*/
952	bool rewrite_SvnNoKeywords(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
953	{
954	RT_NOREF2(pIn, pOut);
955	if ( !pSettings->fSetSvnExecutable
956	\|\| !ScmSvnIsInWorkingCopy(pState))
957	return false;
958
959	int rc = ScmSvnQueryProperty(pState, "svn:keywords", NULL);
960	if (RT_SUCCESS(rc))
961	{
962	ScmVerbose(pState, 2, " * removing svn:keywords\n");
963	rc = ScmSvnDelProperty(pState, "svn:keywords");
964	if (RT_FAILURE(rc))
965	ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
966	}
967	return false;
968	}
969
970	/**
971	* Make sure there is no svn:eol-style property on the current file.
972	*
973	* @returns false - the state carries these kinds of changes.
974	* @param pState The rewriter state.
975	* @param pIn The input stream.
976	* @param pOut The output stream.
977	* @param pSettings The settings.
978	*/
979	bool rewrite_SvnNoEolStyle(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
980	{
981	RT_NOREF2(pIn, pOut);
982	if ( !pSettings->fSetSvnExecutable
983	\|\| !ScmSvnIsInWorkingCopy(pState))
984	return false;
985
986	int rc = ScmSvnQueryProperty(pState, "svn:eol-style", NULL);
987	if (RT_SUCCESS(rc))
988	{
989	ScmVerbose(pState, 2, " * removing svn:eol-style\n");
990	rc = ScmSvnDelProperty(pState, "svn:eol-style");
991	if (RT_FAILURE(rc))
992	ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
993	}
994	return false;
995	}
996
997	/**
998	* Makes sure the svn properties are appropriate for a binary.
999	*
1000	* @returns false - the state carries these kinds of changes.
1001	* @param pState The rewriter state.
1002	* @param pIn The input stream.
1003	* @param pOut The output stream.
1004	* @param pSettings The settings.
1005	*/
1006	bool rewrite_SvnBinary(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1007	{
1008	RT_NOREF2(pIn, pOut);
1009	if ( !pSettings->fSetSvnExecutable
1010	\|\| !ScmSvnIsInWorkingCopy(pState))
1011	return false;
1012
1013	/* remove svn:eol-style and svn:keywords */
1014	static const char * const s_apszRemove[] = { "svn:eol-style", "svn:keywords" };
1015	for (uint32_t i = 0; i < RT_ELEMENTS(s_apszRemove); i++)
1016	{
1017	char *pszValue;
1018	int rc = ScmSvnQueryProperty(pState, s_apszRemove[i], &pszValue);
1019	if (RT_SUCCESS(rc))
1020	{
1021	ScmVerbose(pState, 2, " * removing %s=%s\n", s_apszRemove[i], pszValue);
1022	RTStrFree(pszValue);
1023	rc = ScmSvnDelProperty(pState, s_apszRemove[i]);
1024	if (RT_FAILURE(rc))
1025	ScmError(pState, rc, "ScmSvnSetProperty(,%s): %Rrc\n", s_apszRemove[i], rc);
1026	}
1027	else if (rc != VERR_NOT_FOUND)
1028	ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
1029	}
1030
1031	/* Make sure there is a svn:mime-type set. */
1032	int rc = ScmSvnQueryProperty(pState, "svn:mime-type", NULL);
1033	if (rc == VERR_NOT_FOUND)
1034	{
1035	ScmVerbose(pState, 2, " * settings svn:mime-type\n");
1036	rc = ScmSvnSetProperty(pState, "svn:mime-type", "application/octet-stream");
1037	if (RT_FAILURE(rc))
1038	ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
1039	}
1040	else if (RT_FAILURE(rc))
1041	ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
1042
1043	return false;
1044	}
1045
1046	/**
1047	* Make sure the Id and Revision keywords are expanded.
1048	*
1049	* @returns false - the state carries these kinds of changes.
1050	* @param pState The rewriter state.
1051	* @param pIn The input stream.
1052	* @param pOut The output stream.
1053	* @param pSettings The settings.
1054	*/
1055	bool rewrite_SvnKeywords(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1056	{
1057	RT_NOREF2(pIn, pOut);
1058	if ( !pSettings->fSetSvnKeywords
1059	\|\| !ScmSvnIsInWorkingCopy(pState))
1060	return false;
1061
1062	char *pszKeywords;
1063	int rc = ScmSvnQueryProperty(pState, "svn:keywords", &pszKeywords);
1064	if ( RT_SUCCESS(rc)
1065	&& ( !strstr(pszKeywords, "Id") /** @todo need some function for finding a word in a string. */
1066	\|\| !strstr(pszKeywords, "Revision")) )
1067	{
1068	if (!strstr(pszKeywords, "Id") && !strstr(pszKeywords, "Revision"))
1069	rc = RTStrAAppend(&pszKeywords, " Id Revision");
1070	else if (!strstr(pszKeywords, "Id"))
1071	rc = RTStrAAppend(&pszKeywords, " Id");
1072	else
1073	rc = RTStrAAppend(&pszKeywords, " Revision");
1074	if (RT_SUCCESS(rc))
1075	{
1076	ScmVerbose(pState, 2, " * changing svn:keywords to '%s'\n", pszKeywords);
1077	rc = ScmSvnSetProperty(pState, "svn:keywords", pszKeywords);
1078	if (RT_FAILURE(rc))
1079	ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
1080	}
1081	else
1082	ScmError(pState, rc, "RTStrAppend: %Rrc\n", rc);
1083	RTStrFree(pszKeywords);
1084	}
1085	else if (rc == VERR_NOT_FOUND)
1086	{
1087	ScmVerbose(pState, 2, " * setting svn:keywords to 'Id Revision'\n");
1088	rc = ScmSvnSetProperty(pState, "svn:keywords", "Id Revision");
1089	if (RT_FAILURE(rc))
1090	ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
1091	}
1092	else if (RT_SUCCESS(rc))
1093	RTStrFree(pszKeywords);
1094
1095	return false;
1096	}
1097
1098	/**
1099	* Checks the svn:sync-process value and that parent is exported too.
1100	*
1101	* @returns false - the state carries these kinds of changes.
1102	* @param pState The rewriter state.
1103	* @param pIn The input stream.
1104	* @param pOut The output stream.
1105	* @param pSettings The settings.
1106	*/
1107	bool rewrite_SvnSyncProcess(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1108	{
1109	RT_NOREF2(pIn, pOut);
1110	if ( pSettings->fSkipSvnSyncProcess
1111	\|\| !ScmSvnIsInWorkingCopy(pState))
1112	return false;
1113
1114	char *pszSyncProcess;
1115	int rc = ScmSvnQueryProperty(pState, "svn:sync-process", &pszSyncProcess);
1116	if (RT_SUCCESS(rc))
1117	{
1118	if (strcmp(pszSyncProcess, "export") == 0)
1119	{
1120	char *pszParentSyncProcess;
1121	rc = ScmSvnQueryParentProperty(pState, "svn:sync-process", &pszParentSyncProcess);
1122	if (RT_SUCCESS(rc))
1123	{
1124	if (strcmp(pszSyncProcess, "export") != 0)
1125	ScmError(pState, VERR_INVALID_STATE,
1126	"svn:sync-process=export, but parent directory differs: %s\n"
1127	"WARNING! Make sure to unexport everything inside the directory first!\n"
1128	" Then you may export the directory and stuff inside it if you want.\n"
1129	" (Just exporting the directory will not make anything inside it externally visible.)\n"
1130	, pszParentSyncProcess);
1131	RTStrFree(pszParentSyncProcess);
1132	}
1133	else if (rc == VERR_NOT_FOUND)
1134	ScmError(pState, VERR_NOT_FOUND,
1135	"svn:sync-process=export, but parent directory is not exported!\n"
1136	"WARNING! Make sure to unexport everything inside the directory first!\n"
1137	" Then you may export the directory and stuff inside it if you want.\n"
1138	" (Just exporting the directory will not make anything inside it externally visible.)\n");
1139	else
1140	ScmError(pState, rc, "ScmSvnQueryParentProperty: %Rrc\n", rc);
1141	}
1142	else if (strcmp(pszSyncProcess, "ignore") != 0)
1143	ScmError(pState, VERR_INVALID_NAME, "Bad sync-process value: %s\n", pszSyncProcess);
1144	RTStrFree(pszSyncProcess);
1145	}
1146	else if (rc != VERR_NOT_FOUND)
1147	ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
1148
1149	return false;
1150	}
1151
1152	/**
1153	* Checks the that there is no bidirectional unicode fun in the file.
1154	*
1155	* @returns false - the state carries these kinds of changes.
1156	* @param pState The rewriter state.
1157	* @param pIn The input stream.
1158	* @param pOut The output stream.
1159	* @param pSettings The settings.
1160	*/
1161	bool rewrite_UnicodeChecks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1162	{
1163	RT_NOREF2(pIn, pOut);
1164	if (pSettings->fSkipUnicodeChecks)
1165	return false;
1166
1167	/*
1168	* Just scan the input for weird stuff and fail if we find anything we don't like.
1169	*/
1170	uint32_t iLine = 0;
1171	SCMEOL enmEol;
1172	size_t cchLine;
1173	const char *pchLine;
1174	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
1175	{
1176	iLine++;
1177	const char *pchCur = pchLine;
1178	size_t cchLeft = cchLine;
1179	while (cchLeft > 0)
1180	{
1181	RTUNICP uc = 0;
1182	int rc = RTStrGetCpNEx(&pchCur, &cchLeft, &uc);
1183	if (RT_SUCCESS(rc))
1184	{
1185	const char *pszWhat;
1186	switch (uc)
1187	{
1188	default:
1189	continue;
1190
1191	/* Potentially evil bi-directional control codes (Table I, trojan-source.pdf): */
1192	case 0x202a: pszWhat = "LRE - left-to-right embedding"; break;
1193	case 0x202b: pszWhat = "RLE - right-to-left embedding"; break;
1194	case 0x202d: pszWhat = "LRO - left-to-right override"; break;
1195	case 0x202e: pszWhat = "RLO - right-to-left override"; break;
1196	case 0x2066: pszWhat = "LRI - left-to-right isolate"; break;
1197	case 0x2067: pszWhat = "RLI - right-to-left isolate"; break;
1198	case 0x2068: pszWhat = "FSI - first strong isolate"; break;
1199	case 0x202c: pszWhat = "PDF - pop directional formatting (LRE, RLE, LRO, RLO)"; break;
1200	case 0x2069: pszWhat = "PDI - pop directional isolate (LRI, RLI)"; break;
1201
1202	/** @todo add checks for homoglyphs too. */
1203	}
1204	ScmFixManually(pState, "%u:%zu: Evil unicode codepoint: %s\n", iLine, pchCur - pchLine, pszWhat);
1205	}
1206	else
1207	ScmFixManually(pState, "%u:%zu: Invalid UTF-8 encoding: %Rrc\n", iLine, pchCur - pchLine, rc);
1208	}
1209	}
1210
1211	return false;
1212	}
1213
1214	/**
1215	* Compares two strings word-by-word, ignoring spaces, punctuation and case.
1216	*
1217	* Assumes ASCII strings.
1218	*
1219	* @returns true if they match, false if not.
1220	* @param psz1 The first string. This is typically the known one.
1221	* @param psz2 The second string. This is typically the unknown one,
1222	* which is why we return a next pointer for this one.
1223	* @param ppsz2Next Where to return the next part of the 2nd string. If
1224	* this is NULL, the whole string must match.
1225	*/
1226	static bool IsEqualWordByWordIgnoreCase(const char psz1, const char psz2, const char **ppsz2Next)
1227	{
1228	for (;;)
1229	{
1230	/* Try compare raw strings first. */
1231	char ch1 = *psz1;
1232	char ch2 = *psz2;
1233	if ( ch1 == ch2
1234	\|\| RT_C_TO_LOWER(ch1) == RT_C_TO_LOWER(ch2))
1235	{
1236	if (ch1)
1237	{
1238	psz1++;
1239	psz2++;
1240	}
1241	else
1242	{
1243	if (ppsz2Next)
1244	*ppsz2Next = psz2;
1245	return true;
1246	}
1247	}
1248	else
1249	{
1250	/* Try skip spaces an punctuation. */
1251	while ( RT_C_IS_SPACE(ch1)
1252	\|\| RT_C_IS_PUNCT(ch1))
1253	ch1 = *++psz1;
1254
1255	if (ch1 == '\0' && ppsz2Next)
1256	{
1257	*ppsz2Next = psz2;
1258	return true;
1259	}
1260
1261	while ( RT_C_IS_SPACE(ch2)
1262	\|\| RT_C_IS_PUNCT(ch2))
1263	ch2 = *++psz2;
1264
1265	if ( ch1 != ch2
1266	&& RT_C_TO_LOWER(ch1) != RT_C_TO_LOWER(ch2))
1267	{
1268	if (ppsz2Next)
1269	*ppsz2Next = psz2;
1270	return false;
1271	}
1272	}
1273	}
1274	}
1275
1276	/**
1277	* Looks for @a pszFragment anywhere in @a pszText, ignoring spaces, punctuation
1278	* and case.
1279	*
1280	* @returns true if found, false if not.
1281	* @param pszText The haystack to search in.
1282	* @param cchText The length @a pszText.
1283	* @param pszFragment The needle to search for.
1284	* @param ppszStart Where to return the address in @a pszText where
1285	* the fragment was found. Optional.
1286	* @param ppszNext Where to return the pointer to the first char in
1287	* @a pszText after the fragment. Optional.
1288	*
1289	* @remarks First character of @a pszFragment must be an 7-bit ASCII character!
1290	* This character must not be space or punctuation.
1291	*/
1292	static bool scmContainsWordByWordIgnoreCase(const char pszText, size_t cchText, const char pszFragment,
1293	const char ppszStart, const char ppszNext)
1294	{
1295	Assert(!((unsigned)*pszFragment & 0x80));
1296	Assert(pszText[cchText] == '\0');
1297	Assert(!RT_C_IS_BLANK(*pszFragment));
1298	Assert(!RT_C_IS_PUNCT(*pszFragment));
1299
1300	char chLower = RT_C_TO_LOWER(*pszFragment);
1301	char chUpper = RT_C_TO_UPPER(*pszFragment);
1302	for (;;)
1303	{
1304	const char pszHit = (const char )memchr(pszText, chLower, cchText);
1305	const char pszHit2 = (const char )memchr(pszText, chUpper, cchText);
1306	if (!pszHit && !pszHit2)
1307	{
1308	if (ppszStart)
1309	*ppszStart = NULL;
1310	if (ppszNext)
1311	*ppszNext = NULL;
1312	return false;
1313	}
1314
1315	if ( pszHit == NULL
1316	\|\| ( pszHit2 != NULL
1317	&& ((uintptr_t)pszHit2 < (uintptr_t)pszHit)) )
1318	pszHit = pszHit2;
1319
1320	const char *pszNext;
1321	if (IsEqualWordByWordIgnoreCase(pszFragment, pszHit, &pszNext))
1322	{
1323	if (ppszStart)
1324	*ppszStart = pszHit;
1325	if (ppszNext)
1326	*ppszNext = pszNext;
1327	return true;
1328	}
1329
1330	cchText -= pszHit - pszText + 1;
1331	pszText = pszHit + 1;
1332	}
1333	}
1334
1335
1336	/**
1337	* Counts the number of lines in the given substring.
1338	*
1339	* @returns The number of lines.
1340	* @param psz The start of the substring.
1341	* @param cch The length of the substring.
1342	*/
1343	static uint32_t CountLinesInSubstring(const char *psz, size_t cch)
1344	{
1345	uint32_t cLines = 0;
1346	for (;;)
1347	{
1348	const char pszEol = (const char )memchr(psz, '\n', cch);
1349	if (pszEol)
1350	cLines++;
1351	else
1352	return cLines + (*psz != '\0');
1353	cch -= pszEol + 1 - psz;
1354	if (!cch)
1355	return cLines;
1356	psz = pszEol + 1;
1357	}
1358	}
1359
1360
1361	/**
1362	* Comment parser callback for locating copyright and license.
1363	*/
1364	static DECLCALLBACK(int)
1365	rewrite_Copyright_CommentCallback(PCSCMCOMMENTINFO pInfo, const char pszBody, size_t cchBody, void pvUser)
1366	{
1367	PSCMCOPYRIGHTINFO pState = (PSCMCOPYRIGHTINFO)pvUser;
1368	Assert(strlen(pszBody) == cchBody);
1369	//RTPrintf("--- comment at %u, type %u ---\n%s\n--- end ---\n", pInfo->iLineStart, pInfo->enmType, pszBody);
1370	ScmVerbose(pState->pState, 5,
1371	"--- comment at %u col %u, %u lines, type %u, %u lines before body, %u lines after body\n",
1372	pInfo->iLineStart, pInfo->offStart, pInfo->iLineEnd - pInfo->iLineStart + 1, pInfo->enmType,
1373	pInfo->cBlankLinesBefore, pInfo->cBlankLinesAfter);
1374
1375	pState->cComments++;
1376
1377	uint32_t iLine = pInfo->iLineStart + pInfo->cBlankLinesBefore;
1378
1379	/*
1380	* Look for a 'contributed by' or 'includes contributions from' line, these
1381	* comes first when present.
1382	*/
1383	const char *pchContributedBy = NULL;
1384	size_t cchContributedBy = 0;
1385	size_t cBlankLinesAfterContributedBy = 0;
1386	if ( pState->pszContributedBy == NULL
1387	&& ( pState->iLineCopyright == UINT32_MAX
1388	\|\| pState->iLineLicense == UINT32_MAX)
1389	&& ( ( cchBody > sizeof("Contributed by")
1390	&& RTStrNICmp(pszBody, RT_STR_TUPLE("contributed by")) == 0)
1391	\|\| ( cchBody > sizeof("Includes contributions from")
1392	&& RTStrNICmp(pszBody, RT_STR_TUPLE("Includes contributions from")) == 0) ) )
1393	{
1394	const char pszNextLine = (const char )memchr(pszBody, '\n', cchBody);
1395	while (pszNextLine && pszNextLine[1] != '\n')
1396	pszNextLine = (const char *)memchr(pszNextLine + 1, '\n', cchBody);
1397	if (pszNextLine)
1398	{
1399	pchContributedBy = pszBody;
1400	cchContributedBy = pszNextLine - pszBody;
1401
1402	/* Skip the copyright line and any blank lines following it. */
1403	cchBody -= cchContributedBy + 1;
1404	pszBody = pszNextLine + 1;
1405	iLine += 1;
1406	while (*pszBody == '\n')
1407	{
1408	pszBody++;
1409	cchBody--;
1410	iLine++;
1411	cBlankLinesAfterContributedBy++;
1412	}
1413	}
1414	}
1415
1416	/*
1417	* Look for the copyright line.
1418	*/
1419	bool fFoundCopyright = false;
1420	uint32_t cBlankLinesAfterCopyright = 0;
1421	if ( pState->iLineCopyright == UINT32_MAX
1422	&& cchBody > sizeof("Copyright") + RT_MIN(sizeof(g_szCopyrightHolder), sizeof(g_szOldCopyrightHolder))
1423	&& RTStrNICmp(pszBody, RT_STR_TUPLE("copyright")) == 0)
1424	{
1425	const char pszNextLine = (const char )memchr(pszBody, '\n', cchBody);
1426
1427	/* Oracle copyright? */
1428	const char *pszEnd = pszNextLine ? pszNextLine : &pszBody[cchBody];
1429	while (RT_C_IS_SPACE(pszEnd[-1]))
1430	pszEnd--;
1431	if ( ( (uintptr_t)(pszEnd - pszBody) > sizeof(g_szCopyrightHolder)
1432	&& ((unsigned char )(pszEnd - sizeof(g_szCopyrightHolder) + 1) & 0x80) == 0 /* to avoid annoying assertion */
1433	&& RTStrNICmp(pszEnd - sizeof(g_szCopyrightHolder) + 1, RT_STR_TUPLE(g_szCopyrightHolder)) == 0)
1434	\|\| ( (uintptr_t)(pszEnd - pszBody) > sizeof(g_szOldCopyrightHolder)
1435	&& ((unsigned char )(pszEnd - sizeof(g_szOldCopyrightHolder) + 1) & 0x80) == 0 /* to avoid annoying assertion */
1436	&& RTStrNICmp(pszEnd - sizeof(g_szOldCopyrightHolder) + 1, RT_STR_TUPLE(g_szOldCopyrightHolder)) == 0) )
1437	{
1438	/* Parse out the year(s). */
1439	const char *psz = pszBody + sizeof("copyright");
1440	while ((uintptr_t)psz < (uintptr_t)pszEnd && !RT_C_IS_DIGIT(*psz))
1441	psz++;
1442	if (RT_C_IS_DIGIT(*psz))
1443	{
1444	char *pszNext;
1445	int rc = RTStrToUInt32Ex(psz, &pszNext, 10, &pState->uFirstYear);
1446	if ( RT_SUCCESS(rc)
1447	&& rc != VWRN_NUMBER_TOO_BIG
1448	&& rc != VWRN_NEGATIVE_UNSIGNED)
1449	{
1450	if ( pState->uFirstYear < 1975
1451	\|\| pState->uFirstYear > 3000)
1452	{
1453	char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
1454	RTStrPurgeEncoding(pszCopy);
1455	ScmError(pState->pState, VERR_OUT_OF_RANGE, "Copyright year is out of range: %u ('%s')\n",
1456	pState->uFirstYear, pszCopy);
1457	RTStrFree(pszCopy);
1458	pState->uFirstYear = UINT32_MAX;
1459	}
1460
1461	while (RT_C_IS_SPACE(*pszNext))
1462	pszNext++;
1463	if (*pszNext == '-')
1464	{
1465	do
1466	pszNext++;
1467	while (RT_C_IS_SPACE(*pszNext));
1468	rc = RTStrToUInt32Ex(pszNext, &pszNext, 10, &pState->uLastYear);
1469	if ( RT_SUCCESS(rc)
1470	&& rc != VWRN_NUMBER_TOO_BIG
1471	&& rc != VWRN_NEGATIVE_UNSIGNED)
1472	{
1473	if ( pState->uLastYear < 1975
1474	\|\| pState->uLastYear > 3000)
1475	{
1476	char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
1477	RTStrPurgeEncoding(pszCopy);
1478	ScmError(pState->pState, VERR_OUT_OF_RANGE, "Second copyright year is out of range: %u ('%s')\n",
1479	pState->uLastYear, pszCopy);
1480	RTStrFree(pszCopy);
1481	pState->uLastYear = UINT32_MAX;
1482	}
1483	else if (pState->uFirstYear > pState->uLastYear)
1484	{
1485	char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
1486	RTStrPurgeEncoding(pszCopy);
1487	RTMsgWarning("Copyright years switched(?): '%s'\n", pszCopy);
1488	RTStrFree(pszCopy);
1489	uint32_t iTmp = pState->uLastYear;
1490	pState->uLastYear = pState->uFirstYear;
1491	pState->uFirstYear = iTmp;
1492	}
1493	}
1494	else
1495	{
1496	pState->uLastYear = UINT32_MAX;
1497	char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
1498	RTStrPurgeEncoding(pszCopy);
1499	ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
1500	"Failed to parse second copyright year: '%s'\n", pszCopy);
1501	RTMemFree(pszCopy);
1502	}
1503	}
1504	else if (*pszNext != g_szCopyrightHolder[0])
1505	{
1506	char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
1507	RTStrPurgeEncoding(pszCopy);
1508	ScmError(pState->pState, VERR_PARSE_ERROR,
1509	"Failed to parse copyright: '%s'\n", pszCopy);
1510	RTMemFree(pszCopy);
1511	} else
1512	pState->uLastYear = pState->uFirstYear;
1513	}
1514	else
1515	{
1516	pState->uFirstYear = UINT32_MAX;
1517	char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
1518	RTStrPurgeEncoding(pszCopy);
1519	ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
1520	"Failed to parse copyright year: '%s'\n", pszCopy);
1521	RTMemFree(pszCopy);
1522	}
1523	}
1524
1525	/* The copyright comment must come before the license. */
1526	if (pState->iLineLicense != UINT32_MAX)
1527	ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright (line %u) must come before the license (line %u)!\n",
1528	iLine, pState->iLineLicense);
1529
1530	/* In C/C++ code, this must be a multiline comment. While in python it
1531	must be a */
1532	if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
1533	ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a multiline comment (no doxygen stuff)\n");
1534	else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
1535	ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a doc-string\n");
1536
1537	/* The copyright must be followed by the license. */
1538	if (!pszNextLine)
1539	ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
1540
1541	/* Quit if we've flagged a failure. */
1542	if (RT_FAILURE(pState->pState->rc))
1543	return VERR_CALLBACK_RETURN;
1544
1545	/* Check if it's well formed and up to date. */
1546	char szWellFormed[256];
1547	size_t cchWellFormed;
1548	if (pState->uFirstYear == pState->uLastYear)
1549	cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u %s",
1550	pState->uFirstYear, g_szCopyrightHolder);
1551	else
1552	cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u-%u %s",
1553	pState->uFirstYear, pState->uLastYear, g_szCopyrightHolder);
1554	pState->fUpToDateCopyright = pState->uLastYear == g_uYear;
1555	pState->iLineCopyright = iLine;
1556	pState->fWellFormedCopyright = cchWellFormed == (uintptr_t)(pszEnd - pszBody)
1557	&& memcmp(pszBody, szWellFormed, cchWellFormed) == 0;
1558	if (!pState->fWellFormedCopyright)
1559	ScmVerbose(pState->pState, 1, "* copyright isn't well formed\n");
1560
1561	/* If there wasn't exactly one blank line before the comment, trigger a rewrite. */
1562	if (pInfo->cBlankLinesBefore != 1)
1563	{
1564	ScmVerbose(pState->pState, 1, "* copyright comment is preceeded by %u blank lines instead of 1\n",
1565	pInfo->cBlankLinesBefore);
1566	pState->fWellFormedCopyright = false;
1567	}
1568
1569	/* If the comment doesn't start in column 1, trigger rewrite. */
1570	if (pInfo->offStart != 0)
1571	{
1572	ScmVerbose(pState->pState, 1, "* copyright comment starts in column %u instead of 1\n", pInfo->offStart + 1);
1573	pState->fWellFormedCopyright = false;
1574	/** @todo check that there isn't any code preceeding the comment. */
1575	}
1576
1577	if (pchContributedBy)
1578	{
1579	pState->pszContributedBy = RTStrDupN(pchContributedBy, cchContributedBy);
1580	if (cBlankLinesAfterContributedBy != 1)
1581	{
1582	ScmVerbose(pState->pState, 1, "* %u blank lines between contributed by and copyright, should be 1\n",
1583	cBlankLinesAfterContributedBy);
1584	pState->fWellFormedCopyright = false;
1585	}
1586	}
1587
1588	fFoundCopyright = true;
1589	ScmVerbose(pState->pState, 3, "oracle copyright %u-%u: up-to-date=%RTbool well-formed=%RTbool\n",
1590	pState->uFirstYear, pState->uLastYear, pState->fUpToDateCopyright, pState->fWellFormedCopyright);
1591	}
1592	else
1593	{
1594	char *pszCopy = RTStrDupN(pszBody, pszEnd - pszBody);
1595	RTStrPurgeEncoding(pszCopy);
1596	ScmVerbose(pState->pState, 3, "not oracle copyright: '%s'\n", pszCopy);
1597	RTStrFree(pszCopy);
1598	}
1599
1600	if (!pszNextLine)
1601	return VINF_SUCCESS;
1602
1603	/* Skip the copyright line and any blank lines following it. */
1604	cchBody -= pszNextLine - pszBody + 1;
1605	pszBody = pszNextLine + 1;
1606	iLine += 1;
1607	while (*pszBody == '\n')
1608	{
1609	pszBody++;
1610	cchBody--;
1611	iLine++;
1612	cBlankLinesAfterCopyright++;
1613	}
1614
1615	/*
1616	* If we have a based-on-mit scenario, check for the lead in now and
1617	* complain if not found.
1618	*/
1619	if ( fFoundCopyright
1620	&& pState->enmLicenceOpt == kScmLicense_BasedOnMit
1621	&& pState->iLineLicense == UINT32_MAX)
1622	{
1623	if (RTStrNICmp(pszBody, RT_STR_TUPLE("This file is based on ")) == 0)
1624	{
1625	/* Take down a comment area which goes up to 'this file is based on'.
1626	The license line and length isn't used but gets set to cover the current line. */
1627	pState->iLineComment = pInfo->iLineStart;
1628	pState->cLinesComment = iLine - pInfo->iLineStart;
1629	pState->iLineLicense = iLine;
1630	pState->cLinesLicense = 1;
1631	pState->fExternalLicense = true;
1632	pState->fIsCorrectLicense = true;
1633	pState->fWellFormedLicense = true;
1634
1635	/* Check if we've got a MIT a license here or not. */
1636	pState->pCurrentLicense = NULL;
1637	do
1638	{
1639	const char pszEol = (const char )memchr(pszBody, '\n', cchBody);
1640	if (!pszEol \|\| pszEol[1] == '\0')
1641	{
1642	pszBody += cchBody;
1643	cchBody = 0;
1644	break;
1645	}
1646	cchBody -= pszEol - pszBody + 1;
1647	pszBody = pszEol + 1;
1648	iLine++;
1649
1650	for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
1651	{
1652	const char *pszNext;
1653	if ( pCur->cch <= cchBody + 32 /* (+ 32 since we don't compare spaces and punctuation) */
1654	&& IsEqualWordByWordIgnoreCase(pCur->psz, pszBody, &pszNext))
1655	{
1656	pState->pCurrentLicense = pCur;
1657	break;
1658	}
1659	}
1660	} while (!pState->pCurrentLicense);
1661	if (!pState->pCurrentLicense)
1662	ScmError(pState->pState, VERR_NOT_FOUND, "Could not find the based-on license!\n");
1663	else if (pState->pCurrentLicense->enmType != kScmLicenseType_Mit)
1664	ScmError(pState->pState, VERR_NOT_FOUND, "The based-on license is not MIT (%.32s...)\n",
1665	pState->pCurrentLicense->psz);
1666	}
1667	else
1668	ScmError(pState->pState, VERR_WRONG_ORDER, "Expected 'This file is based on ...' after our copyright!\n");
1669	return VINF_SUCCESS;
1670	}
1671	}
1672
1673	/*
1674	* Look for LGPL like text in the comment.
1675	*/
1676	if (pState->fCheckforLgpl && cchBody > 128)
1677	{
1678	/* We look for typical LGPL notices. */
1679	if (pState->iLineLgplNotice == UINT32_MAX)
1680	{
1681	static const char * const s_apszFragments[] =
1682	{
1683	"under the terms of the GNU Lesser General Public License",
1684	};
1685	for (unsigned i = 0; i < RT_ELEMENTS(s_apszFragments); i++)
1686	if (scmContainsWordByWordIgnoreCase(pszBody, cchBody, s_apszFragments[i], NULL, NULL))
1687	{
1688	pState->iLineLgplNotice = iLine;
1689	pState->iLineAfterLgplComment = pInfo->iLineEnd + 1;
1690	ScmVerbose(pState->pState, 3, "Found LGPL notice at %u\n", iLine);
1691	break;
1692	}
1693	}
1694
1695	if ( pState->iLineLgplDisclaimer == UINT32_MAX
1696	&& scmContainsWordByWordIgnoreCase(pszBody, cchBody, g_szLgplDisclaimer, NULL, NULL))
1697	{
1698	pState->iLineLgplDisclaimer = iLine;
1699	ScmVerbose(pState->pState, 3, "Found LGPL disclaimer at %u\n", iLine);
1700	}
1701	}
1702
1703	/*
1704	* Look for the license text.
1705	*/
1706	if (pState->iLineLicense == UINT32_MAX)
1707	{
1708	for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
1709	{
1710	const char *pszNext;
1711	if ( pCur->cch <= cchBody + 32 /* (+ 32 since we don't compare spaces and punctuation) */
1712	&& IsEqualWordByWordIgnoreCase(pCur->psz, pszBody, &pszNext))
1713	{
1714	while ( RT_C_IS_SPACE(*pszNext)
1715	\|\| (RT_C_IS_PUNCT(pszNext) && pszNext != '-'))
1716	pszNext++;
1717
1718	uint32_t cDashes = 0;
1719	while (*pszNext == '-')
1720	cDashes++, pszNext++;
1721	bool fExternal = cDashes > 10;
1722
1723	if ( *pszNext == '\0'
1724	\|\| fExternal)
1725	{
1726	/* In C/C++ code, this must be a multiline comment. While in python it
1727	must be a doc-string. */
1728	if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
1729	ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a multiline comment (no doxygen stuff)\n");
1730	else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
1731	ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a doc-string\n");
1732
1733	/* Quit if we've flagged a failure. */
1734	if (RT_FAILURE(pState->pState->rc))
1735	return VERR_CALLBACK_RETURN;
1736
1737	/* Record it. */
1738	pState->iLineLicense = iLine;
1739	pState->cLinesLicense = CountLinesInSubstring(pszBody, pszNext - pszBody) - fExternal;
1740	pState->pCurrentLicense = pCur;
1741	pState->fExternalLicense = fExternal;
1742	pState->fIsCorrectLicense = pCur == pState->pExpectedLicense;
1743	pState->fWellFormedLicense = memcmp(pszBody, pCur->psz, pCur->cch - 1) == 0;
1744	if (!pState->fWellFormedLicense)
1745	ScmVerbose(pState->pState, 1, "* license text isn't well-formed\n");
1746
1747	/* If there was more than one blank line between the copyright and the
1748	license text, extend the license text area and force a rewrite of it. */
1749	if (cBlankLinesAfterCopyright > 1)
1750	{
1751	ScmVerbose(pState->pState, 1, "* %u blank lines between copyright and license text, instead of 1\n",
1752	cBlankLinesAfterCopyright);
1753	pState->iLineLicense -= cBlankLinesAfterCopyright - 1;
1754	pState->cLinesLicense += cBlankLinesAfterCopyright - 1;
1755	pState->fWellFormedLicense = false;
1756	}
1757
1758	/* If there was more than one blank line after the license, trigger a rewrite. */
1759	if (!fExternal && pInfo->cBlankLinesAfter != 1)
1760	{
1761	ScmVerbose(pState->pState, 1, "* copyright comment is followed by %u blank lines instead of 1\n",
1762	pInfo->cBlankLinesAfter);
1763	pState->fWellFormedLicense = false;
1764	}
1765
1766	/** @todo Check that the last comment line doesn't have any code on it. */
1767	/** @todo Check that column 2 contains '' for C/C++ files. /
1768
1769	ScmVerbose(pState->pState, 3,
1770	"Found license %d/%d at %u..%u: is-correct=%RTbool well-formed=%RTbool external-part=%RTbool open-source=%RTbool\n",
1771	pCur->enmType, pCur->enmOpt, pState->iLineLicense, pState->iLineLicense + pState->cLinesLicense,
1772	pState->fIsCorrectLicense, pState->fWellFormedLicense,
1773	pState->fExternalLicense, pState->fOpenSource);
1774
1775	if (fFoundCopyright)
1776	{
1777	pState->iLineComment = pInfo->iLineStart;
1778	pState->cLinesComment = (fExternal ? pState->iLineLicense + pState->cLinesLicense : pInfo->iLineEnd + 1)
1779	- pInfo->iLineStart;
1780	}
1781	else
1782	ScmError(pState->pState, VERR_WRONG_ORDER, "License should be preceeded by the copyright!\n");
1783	break;
1784	}
1785	}
1786	}
1787	}
1788
1789	if (fFoundCopyright && pState->iLineLicense == UINT32_MAX)
1790	ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
1791
1792	/*
1793	* Stop looking for stuff after 100 comments.
1794	*/
1795	if (pState->cComments > 100)
1796	return VERR_CALLBACK_RETURN;
1797	return VINF_SUCCESS;
1798	}
1799
1800	/**
1801	* Writes comment body text.
1802	*
1803	* @returns Stream status.
1804	* @param pOut The output stream.
1805	* @param pszText The text to write.
1806	* @param cchText The length of the text.
1807	* @param enmCommentStyle The comment style.
1808	* @param enmEol The EOL style.
1809	*/
1810	static int scmWriteCommentBody(PSCMSTREAM pOut, const char *pszText, size_t cchText,
1811	SCMCOMMENTSTYLE enmCommentStyle, SCMEOL enmEol)
1812	{
1813	Assert(pszText[cchText - 1] == '\n');
1814	Assert(pszText[cchText - 2] != '\n');
1815	NOREF(cchText);
1816	do
1817	{
1818	const char *pszEol = strchr(pszText, '\n');
1819	if (pszEol != pszText)
1820	{
1821	ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
1822	g_aCopyrightCommentPrefix[enmCommentStyle].cch);
1823	ScmStreamWrite(pOut, pszText, pszEol - pszText);
1824	ScmStreamPutEol(pOut, enmEol);
1825	}
1826	else
1827	ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
1828	g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
1829	pszText = pszEol + 1;
1830	} while (*pszText != '\0');
1831	return ScmStreamGetStatus(pOut);
1832	}
1833
1834
1835	/**
1836	* Updates the copyright year and/or license text.
1837	*
1838	* @returns true if modifications were made, false if not.
1839	* @param pState The rewriter state.
1840	* @param pIn The input stream.
1841	* @param pOut The output stream.
1842	* @param pSettings The settings.
1843	* @param enmCommentStyle The comment style used by the file.
1844	*/
1845	static bool rewrite_Copyright_Common(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
1846	SCMCOMMENTSTYLE enmCommentStyle)
1847	{
1848	if ( !pSettings->fUpdateCopyrightYear
1849	&& pSettings->enmUpdateLicense == kScmLicense_LeaveAlone)
1850	return false;
1851
1852	/*
1853	* Try locate the relevant comments.
1854	*/
1855	SCMCOPYRIGHTINFO Info =
1856	{
1857	/.pState = / pState,
1858	/.enmCommentStyle = / enmCommentStyle,
1859
1860	/.cComments = / 0,
1861
1862	/.pszContributedBy = / NULL,
1863
1864	/.iLineComment = / UINT32_MAX,
1865	/.cLinesComment = / 0,
1866
1867	/.iLineCopyright = / UINT32_MAX,
1868	/.uFirstYear = / UINT32_MAX,
1869	/.uLastYear = / UINT32_MAX,
1870	/.fWellFormedCopyright = / false,
1871	/.fUpToDateCopyright = / false,
1872
1873	/.fOpenSource = / true,
1874	/.pExpectedLicense = / NULL,
1875	/.paLicenses = / pSettings->enmUpdateLicense != kScmLicense_Mit
1876	&& pSettings->enmUpdateLicense != kScmLicense_BasedOnMit
1877	? &g_aLicenses[0] : &g_aLicensesWithMit[0],
1878	/.enmLicenceOpt = / pSettings->enmUpdateLicense,
1879	/.iLineLicense = / UINT32_MAX,
1880	/.cLinesLicense = / 0,
1881	/.pCurrentLicense = / NULL,
1882	/.fIsCorrectLicense = / false,
1883	/.fWellFormedLicense = / false,
1884	/.fExternalLicense = / false,
1885
1886	/.fCheckForLgpl = / true,
1887	/.iLineLgplNotice = / UINT32_MAX,
1888	/.iLineAfterLgplComment = / UINT32_MAX,
1889	/.iLineLgplDisclaimer = / UINT32_MAX,
1890	};
1891
1892	/* Figure Info.fOpenSource and the desired license: */
1893	char *pszSyncProcess;
1894	int rc = ScmSvnQueryProperty(pState, "svn:sync-process", &pszSyncProcess);
1895	if (RT_SUCCESS(rc))
1896	{
1897	Info.fOpenSource = strcmp(RTStrStrip(pszSyncProcess), "export") == 0;
1898	RTStrFree(pszSyncProcess);
1899	}
1900	else if (rc == VERR_NOT_FOUND)
1901	Info.fOpenSource = false;
1902	else
1903	return ScmError(pState, rc, "ScmSvnQueryProperty(svn:sync-process): %Rrc\n", rc);
1904
1905	Info.pExpectedLicense = Info.paLicenses;
1906	if (Info.fOpenSource)
1907	{
1908	if ( pSettings->enmUpdateLicense != kScmLicense_Mit
1909	&& pSettings->enmUpdateLicense != kScmLicense_BasedOnMit)
1910	while (Info.pExpectedLicense->enmOpt != pSettings->enmUpdateLicense)
1911	Info.pExpectedLicense++;
1912	else
1913	Assert(Info.pExpectedLicense->enmOpt == kScmLicense_Mit);
1914	}
1915	else
1916	while (Info.pExpectedLicense->enmType != kScmLicenseType_Confidential)
1917	Info.pExpectedLicense++;
1918
1919	/* Scan the comments. */
1920	rc = ScmEnumerateComments(pIn, enmCommentStyle, rewrite_Copyright_CommentCallback, &Info);
1921	if ( (rc == VERR_CALLBACK_RETURN \|\| RT_SUCCESS(rc))
1922	&& RT_SUCCESS(pState->rc))
1923	{
1924	/*
1925	* Do conformity checks.
1926	*/
1927	bool fAddLgplDisclaimer = false;
1928	if (Info.fCheckforLgpl)
1929	{
1930	if ( Info.iLineLgplNotice != UINT32_MAX
1931	&& Info.iLineLgplDisclaimer == UINT32_MAX)
1932	{
1933	if (!pSettings->fLgplDisclaimer) /** @todo reconcile options with common sense. */
1934	ScmError(pState, VERR_NOT_FOUND, "LGPL licence notice on line %u, but no LGPL disclaimer was found!\n",
1935	Info.iLineLgplNotice + 1);
1936	else
1937	{
1938	ScmVerbose(pState, 1, "* Need to add LGPL disclaimer\n");
1939	fAddLgplDisclaimer = true;
1940	}
1941	}
1942	else if ( Info.iLineLgplNotice == UINT32_MAX
1943	&& Info.iLineLgplDisclaimer != UINT32_MAX)
1944	ScmError(pState, VERR_NOT_FOUND, "LGPL disclaimer on line %u, but no LGPL copyright notice!\n",
1945	Info.iLineLgplDisclaimer + 1);
1946	}
1947
1948	if (!pSettings->fExternalCopyright)
1949	{
1950	if (Info.iLineCopyright == UINT32_MAX)
1951	ScmError(pState, VERR_NOT_FOUND, "Missing copyright!\n");
1952	if (Info.iLineLicense == UINT32_MAX)
1953	ScmError(pState, VERR_NOT_FOUND, "Missing license!\n");
1954	}
1955	else if (Info.iLineCopyright != UINT32_MAX)
1956	ScmError(pState, VERR_NOT_FOUND,
1957	"Marked as external copyright only, but found non-external copyright statement at line %u!\n",
1958	Info.iLineCopyright + 1);
1959
1960
1961	if (RT_SUCCESS(pState->rc))
1962	{
1963	/*
1964	* Do we need to make any changes?
1965	*/
1966	bool fUpdateCopyright = !pSettings->fExternalCopyright
1967	&& ( !Info.fWellFormedCopyright
1968	\|\| (!Info.fUpToDateCopyright && pSettings->fUpdateCopyrightYear));
1969	bool fUpdateLicense = !pSettings->fExternalCopyright
1970	&& Info.enmLicenceOpt != kScmLicense_LeaveAlone
1971	&& ( !Info.fWellFormedLicense
1972	\|\| !Info.fIsCorrectLicense);
1973	if ( fUpdateCopyright
1974	\|\| fUpdateLicense
1975	\|\| fAddLgplDisclaimer)
1976	{
1977	Assert(Info.iLineComment != UINT32_MAX);
1978	Assert(Info.cLinesComment > 0);
1979
1980	/*
1981	* Okay, do the work.
1982	*/
1983	ScmStreamRewindForReading(pIn);
1984
1985	if (pSettings->fUpdateCopyrightYear)
1986	Info.uLastYear = g_uYear;
1987
1988	uint32_t iLine = 0;
1989	SCMEOL enmEol;
1990	size_t cchLine;
1991	const char *pchLine;
1992	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
1993	{
1994	if ( iLine == Info.iLineComment
1995	&& (fUpdateCopyright \|\| fUpdateLicense) )
1996	{
1997	/* Leading blank line. */
1998	ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
1999	g_aCopyrightCommentStart[enmCommentStyle].cch, enmEol);
2000
2001	/* Contributed by someone? */
2002	if (Info.pszContributedBy)
2003	{
2004	const char *psz = Info.pszContributedBy;
2005	for (;;)
2006	{
2007	const char *pszEol = strchr(psz, '\n');
2008	size_t cchContribLine = pszEol ? pszEol - psz : strlen(psz);
2009	ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
2010	g_aCopyrightCommentPrefix[enmCommentStyle].cch);
2011	ScmStreamWrite(pOut, psz, cchContribLine);
2012	ScmStreamPutEol(pOut, enmEol);
2013	if (!pszEol)
2014	break;
2015	psz = pszEol + 1;
2016	}
2017
2018	ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
2019	g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
2020	}
2021
2022	/* Write the copyright comment line. */
2023	ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
2024	g_aCopyrightCommentPrefix[enmCommentStyle].cch);
2025
2026	char szCopyright[256];
2027	size_t cchCopyright;
2028	if (Info.uFirstYear == Info.uLastYear)
2029	cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u %s",
2030	Info.uFirstYear, g_szCopyrightHolder);
2031	else
2032	cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u-%u %s",
2033	Info.uFirstYear, Info.uLastYear, g_szCopyrightHolder);
2034
2035	ScmStreamWrite(pOut, szCopyright, cchCopyright);
2036	ScmStreamPutEol(pOut, enmEol);
2037
2038	if (pSettings->enmUpdateLicense != kScmLicense_BasedOnMit)
2039	{
2040	/* Blank line separating the two. */
2041	ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
2042	g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
2043
2044	/* Write the license text. */
2045	scmWriteCommentBody(pOut, Info.pExpectedLicense->psz, Info.pExpectedLicense->cch,
2046	enmCommentStyle, enmEol);
2047
2048	/* Final comment line. */
2049	if (!Info.fExternalLicense)
2050	ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
2051	g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
2052	}
2053	else
2054	Assert(Info.fExternalLicense);
2055
2056	/* Skip the copyright and license text in the input file. */
2057	rc = ScmStreamGetStatus(pOut);
2058	if (RT_SUCCESS(rc))
2059	{
2060	iLine = Info.iLineComment + Info.cLinesComment;
2061	rc = ScmStreamSeekByLine(pIn, iLine);
2062	}
2063	}
2064	/*
2065	* Add LGPL disclaimer?
2066	*/
2067	else if ( iLine == Info.iLineAfterLgplComment
2068	&& fAddLgplDisclaimer)
2069	{
2070	ScmStreamPutEol(pOut, enmEol);
2071	ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
2072	g_aCopyrightCommentStart[enmCommentStyle].cch, enmEol);
2073	scmWriteCommentBody(pOut, g_szLgplDisclaimer, sizeof(g_szLgplDisclaimer) - 1,
2074	enmCommentStyle, enmEol);
2075	ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
2076	g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
2077
2078	/* put the actual line */
2079	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
2080	iLine++;
2081	}
2082	else
2083	{
2084	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
2085	iLine++;
2086	}
2087	if (RT_FAILURE(rc))
2088	{
2089	RTStrFree(Info.pszContributedBy);
2090	return false;
2091	}
2092	} /* for each source line */
2093
2094	RTStrFree(Info.pszContributedBy);
2095	return true;
2096	}
2097	}
2098	}
2099	else
2100	ScmError(pState, rc, "ScmEnumerateComments: %Rrc\n", rc);
2101	NOREF(pState); NOREF(pOut);
2102	RTStrFree(Info.pszContributedBy);
2103	return false;
2104	}
2105
2106
2107	/** Copyright updater for C-style comments. */
2108	bool rewrite_Copyright_CstyleComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2109	{
2110	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_C);
2111	}
2112
2113	/** Copyright updater for hash-prefixed comments. */
2114	bool rewrite_Copyright_HashComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2115	{
2116	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Hash);
2117	}
2118
2119	/** Copyright updater for REM-prefixed comments. */
2120	bool rewrite_Copyright_RemComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2121	{
2122	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, determineBatchFileCommentStyle(pIn));
2123	}
2124
2125	/** Copyright updater for python comments. */
2126	bool rewrite_Copyright_PythonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2127	{
2128	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Python);
2129	}
2130
2131	/** Copyright updater for semicolon-prefixed comments. */
2132	bool rewrite_Copyright_SemicolonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2133	{
2134	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Semicolon);
2135	}
2136
2137	/** Copyright updater for sql comments. */
2138	bool rewrite_Copyright_SqlComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2139	{
2140	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Sql);
2141	}
2142
2143	/** Copyright updater for tick-prefixed comments. */
2144	bool rewrite_Copyright_TickComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2145	{
2146	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Tick);
2147	}
2148
2149	/** Copyright updater for XML comments. */
2150	bool rewrite_Copyright_XmlComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2151	{
2152	return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Xml);
2153	}
2154
2155
2156	/**
2157	* Makefile.kup are empty files, enforce this.
2158	*
2159	* @returns true if modifications were made, false if not.
2160	* @param pIn The input stream.
2161	* @param pOut The output stream.
2162	* @param pSettings The settings.
2163	*/
2164	bool rewrite_Makefile_kup(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2165	{
2166	RT_NOREF2(pOut, pSettings);
2167
2168	/* These files should be zero bytes. */
2169	if (pIn->cb == 0)
2170	return false;
2171	ScmVerbose(pState, 2, " * Truncated file to zero bytes\n");
2172	return true;
2173	}
2174
2175	/**
2176	* Rewrite a kBuild makefile.
2177	*
2178	* @returns true if modifications were made, false if not.
2179	* @param pIn The input stream.
2180	* @param pOut The output stream.
2181	* @param pSettings The settings.
2182	*
2183	* @todo
2184	*
2185	* Ideas for Makefile.kmk and Config.kmk:
2186	* - sort if1of/ifn1of sets.
2187	* - line continuation slashes should only be preceded by one space.
2188	*/
2189	bool rewrite_Makefile_kmk(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2190	{
2191	RT_NOREF4(pState, pIn, pOut, pSettings);
2192	return false;
2193	}
2194
2195
2196	static bool isFlowerBoxSectionMarker(PSCMSTREAM pIn, const char *pchLine, size_t cchLine, uint32_t cchWidth,
2197	const char *ppchText, size_t pcchText, bool *pfNeedFixing)
2198	{
2199	*ppchText = NULL;
2200	*pcchText = 0;
2201	*pfNeedFixing = false;
2202
2203	/*
2204	* The first line.
2205	*/
2206	if (pchLine[0] != '/')
2207	return false;
2208	size_t offLine = 1;
2209	while (offLine < cchLine && pchLine[offLine] == '*')
2210	offLine++;
2211	if (offLine < 20) /* (Code below depend on a reasonable minimum here.) */
2212	return false;
2213	while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
2214	offLine++;
2215	if (offLine != cchLine)
2216	return false;
2217
2218	size_t const cchBox = cchLine;
2219	*pfNeedFixing = cchBox != cchWidth;
2220
2221	/*
2222	* The next line, extracting the text.
2223	*/
2224	SCMEOL enmEol;
2225	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
2226	if (cchLine < cchBox - 3)
2227	return false;
2228
2229	offLine = 0;
2230	if (RT_C_IS_BLANK(pchLine[0]))
2231	{
2232	*pfNeedFixing = true;
2233	offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
2234	}
2235
2236	if (pchLine[offLine] != '*')
2237	return false;
2238	offLine++;
2239
2240	if (!RT_C_IS_BLANK(pchLine[offLine + 1]))
2241	return false;
2242	offLine++;
2243
2244	while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
2245	offLine++;
2246	if (offLine >= cchLine)
2247	return false;
2248	if (!RT_C_IS_UPPER(pchLine[offLine]))
2249	return false;
2250
2251	if (offLine != 4 \|\| cchLine != cchBox)
2252	*pfNeedFixing = true;
2253
2254	*ppchText = &pchLine[offLine];
2255	size_t const offText = offLine;
2256
2257	/* From the end now. */
2258	offLine = cchLine - 1;
2259	while (RT_C_IS_BLANK(pchLine[offLine]))
2260	offLine--;
2261
2262	if (pchLine[offLine] != '*')
2263	return false;
2264	offLine--;
2265	if (!RT_C_IS_BLANK(pchLine[offLine]))
2266	return false;
2267	offLine--;
2268	while (RT_C_IS_BLANK(pchLine[offLine]))
2269	offLine--;
2270	*pcchText = offLine - offText + 1;
2271
2272	/*
2273	* Third line closes the box.
2274	*/
2275	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
2276	if (cchLine < cchBox - 3)
2277	return false;
2278
2279	offLine = 0;
2280	if (RT_C_IS_BLANK(pchLine[0]))
2281	{
2282	*pfNeedFixing = true;
2283	offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
2284	}
2285	while (offLine < cchLine && pchLine[offLine] == '*')
2286	offLine++;
2287	if (offLine < cchBox - 4)
2288	return false;
2289
2290	if (pchLine[offLine] != '/')
2291	return false;
2292	offLine++;
2293
2294	if (offLine != cchBox)
2295	*pfNeedFixing = true;
2296
2297	while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
2298	offLine++;
2299	if (offLine != cchLine)
2300	return false;
2301
2302	return true;
2303	}
2304
2305
2306	/**
2307	* Flower box marker comments in C and C++ code.
2308	*
2309	* @returns true if modifications were made, false if not.
2310	* @param pIn The input stream.
2311	* @param pOut The output stream.
2312	* @param pSettings The settings.
2313	*/
2314	bool rewrite_FixFlowerBoxMarkers(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2315	{
2316	if (!pSettings->fFixFlowerBoxMarkers)
2317	return false;
2318
2319	/*
2320	* Work thru the file line by line looking for flower box markers.
2321	*/
2322	size_t cChanges = 0;
2323	size_t cBlankLines = 0;
2324	SCMEOL enmEol;
2325	size_t cchLine;
2326	const char *pchLine;
2327	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
2328	{
2329	/*
2330	* Get a likely match for a first line.
2331	*/
2332	if ( pchLine[0] == '/'
2333	&& cchLine > 20
2334	&& pchLine[1] == '*'
2335	&& pchLine[2] == '*'
2336	&& pchLine[3] == '*')
2337	{
2338	size_t const offSaved = ScmStreamTell(pIn);
2339	char const *pchText;
2340	size_t cchText;
2341	bool fNeedFixing;
2342	bool fIsFlowerBoxSection = isFlowerBoxSectionMarker(pIn, pchLine, cchLine, pSettings->cchWidth,
2343	&pchText, &cchText, &fNeedFixing);
2344	if ( fIsFlowerBoxSection
2345	&& ( fNeedFixing
2346	\|\| cBlankLines < pSettings->cMinBlankLinesBeforeFlowerBoxMakers) )
2347	{
2348	while (cBlankLines < pSettings->cMinBlankLinesBeforeFlowerBoxMakers)
2349	{
2350	ScmStreamPutEol(pOut, enmEol);
2351	cBlankLines++;
2352	}
2353
2354	ScmStreamPutCh(pOut, '/');
2355	ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
2356	ScmStreamPutEol(pOut, enmEol);
2357
2358	static const char s_szLead[] = "* ";
2359	ScmStreamWrite(pOut, s_szLead, sizeof(s_szLead) - 1);
2360	ScmStreamWrite(pOut, pchText, cchText);
2361	size_t offCurPlus1 = sizeof(s_szLead) - 1 + cchText + 1;
2362	ScmStreamWrite(pOut, g_szSpaces, offCurPlus1 < pSettings->cchWidth ? pSettings->cchWidth - offCurPlus1 : 1);
2363	ScmStreamPutCh(pOut, '*');
2364	ScmStreamPutEol(pOut, enmEol);
2365
2366	ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
2367	ScmStreamPutCh(pOut, '/');
2368	ScmStreamPutEol(pOut, enmEol);
2369
2370	cChanges++;
2371	cBlankLines = 0;
2372	continue;
2373	}
2374
2375	int rc = ScmStreamSeekAbsolute(pIn, offSaved);
2376	if (RT_FAILURE(rc))
2377	return false;
2378	}
2379
2380	int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
2381	if (RT_FAILURE(rc))
2382	return false;
2383
2384	/* Do blank line accounting so we can ensure at least two blank lines
2385	before each section marker. */
2386	if (!isBlankLine(pchLine, cchLine))
2387	cBlankLines = 0;
2388	else
2389	cBlankLines++;
2390	}
2391	if (cChanges > 0)
2392	ScmVerbose(pState, 2, " * Converted %zu flower boxer markers\n", cChanges);
2393	return cChanges != 0;
2394	}
2395
2396
2397	/**
2398	* Looks for the start of a todo comment.
2399	*
2400	* @returns Offset into the line of the comment start sequence.
2401	* @param pchLine The line to search.
2402	* @param cchLineBeforeTodo The length of the line before the todo.
2403	* @param pfSameLine Indicates whether it's refering to a statemtn on
2404	* the same line comment (true), or the next
2405	* statement (false).
2406	*/
2407	static size_t findTodoCommentStart(char const pchLine, size_t cchLineBeforeTodo, bool pfSameLine)
2408	{
2409	*pfSameLine = false;
2410
2411	/* Skip one '@' or '\\'. */
2412	char ch;
2413	if ( cchLineBeforeTodo > 2
2414	&& ( ((ch = pchLine[cchLineBeforeTodo - 1]) == '@')
2415	\|\| ch == '\\' ) )
2416	cchLineBeforeTodo--;
2417
2418	/* Skip blanks. */
2419	while ( cchLineBeforeTodo > 2
2420	&& RT_C_IS_BLANK(pchLine[cchLineBeforeTodo - 1]))
2421	cchLineBeforeTodo--;
2422
2423	/* Look for same line indicator. */
2424	if ( cchLineBeforeTodo > 0
2425	&& pchLine[cchLineBeforeTodo - 1] == '<')
2426	{
2427	*pfSameLine = true;
2428	cchLineBeforeTodo--;
2429	}
2430
2431	/* Skip s /
2432	while ( cchLineBeforeTodo > 1
2433	&& pchLine[cchLineBeforeTodo - 1] == '*')
2434	cchLineBeforeTodo--;
2435
2436	/* Do we have a comment opening sequence. */
2437	if ( cchLineBeforeTodo > 0
2438	&& pchLine[cchLineBeforeTodo - 1] == '/'
2439	&& ( ( cchLineBeforeTodo >= 2
2440	&& pchLine[cchLineBeforeTodo - 2] == '/')
2441	\|\| pchLine[cchLineBeforeTodo] == '*'))
2442	{
2443	/* Skip slashes at the start. */
2444	while ( cchLineBeforeTodo > 0
2445	&& pchLine[cchLineBeforeTodo - 1] == '/')
2446	cchLineBeforeTodo--;
2447
2448	return cchLineBeforeTodo;
2449	}
2450
2451	return ~(size_t)0;
2452	}
2453
2454
2455	/**
2456	* Looks for a TODO or todo in the given line.
2457	*
2458	* @returns Offset into the line of found, ~(size_t)0 if not.
2459	* @param pchLine The line to search.
2460	* @param cchLine The length of the line.
2461	*/
2462	static size_t findTodo(char const *pchLine, size_t cchLine)
2463	{
2464	if (cchLine >= 4 + 2)
2465	{
2466	/* We don't search the first to chars because we need the start of a comment.
2467	Also, skip the last three chars since we need at least four for a match. */
2468	size_t const cchLineT = cchLine - 3;
2469	if ( memchr(pchLine + 2, 't', cchLineT - 2) != NULL
2470	\|\| memchr(pchLine + 2, 'T', cchLineT - 2) != NULL)
2471	{
2472	for (size_t off = 2; off < cchLineT; off++)
2473	{
2474	char ch = pchLine[off];
2475	if ( ( ch != 't'
2476	&& ch != 'T')
2477	\|\| ( (ch = pchLine[off + 1]) != 'o'
2478	&& ch != 'O')
2479	\|\| ( (ch = pchLine[off + 2]) != 'd'
2480	&& ch != 'D')
2481	\|\| ( (ch = pchLine[off + 3]) != 'o'
2482	&& ch != 'O')
2483	\|\| ( off + 4 != cchLine
2484	&& (ch = pchLine[off + 4]) != ' '
2485	&& ch != '\t'
2486	&& ch != ':' /** @todo */
2487	&& (ch != '' \|\| off + 5 > cchLine \|\| pchLine[off + 5] != '/') /* @todo */
2488	) )
2489	{ /* not a hit - likely */ }
2490	else
2491	return off;
2492	}
2493	}
2494	}
2495	return ~(size_t)0;
2496	}
2497
2498
2499	/**
2500	* Doxygen todos in C and C++ code.
2501	*
2502	* @returns true if modifications were made, false if not.
2503	* @param pState The rewriter state.
2504	* @param pIn The input stream.
2505	* @param pOut The output stream.
2506	* @param pSettings The settings.
2507	*/
2508	bool rewrite_Fix_C_and_CPP_Todos(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2509	{
2510	if (!pSettings->fFixTodos)
2511	return false;
2512
2513	/*
2514	* Work thru the file line by line looking for the start of todo comments.
2515	*/
2516	size_t cChanges = 0;
2517	SCMEOL enmEol;
2518	size_t cchLine;
2519	const char *pchLine;
2520	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
2521	{
2522	/*
2523	* Look for the word 'todo' in the line. We're currently only trying
2524	* to catch comments starting with the word todo and adjust the start of
2525	* the doxygen statement.
2526	*/
2527	size_t offTodo = findTodo(pchLine, cchLine);
2528	if ( offTodo != ~(size_t)0
2529	&& offTodo >= 2)
2530	{
2531	/* Work backwards to find the start of the comment. */
2532	bool fSameLine = false;
2533	size_t offCommentStart = findTodoCommentStart(pchLine, offTodo, &fSameLine);
2534	if (offCommentStart != ~(size_t)0)
2535	{
2536	char szNew[64];
2537	size_t cchNew = 0;
2538	szNew[cchNew++] = '/';
2539	szNew[cchNew++] = pchLine[offCommentStart + 1];
2540	szNew[cchNew++] = pchLine[offCommentStart + 1];
2541	if (fSameLine)
2542	szNew[cchNew++] = '<';
2543	szNew[cchNew++] = ' ';
2544	szNew[cchNew++] = '@';
2545	szNew[cchNew++] = 't';
2546	szNew[cchNew++] = 'o';
2547	szNew[cchNew++] = 'd';
2548	szNew[cchNew++] = 'o';
2549
2550	/* Figure out wheter to continue after the @todo statement opening, we'll strip ':'
2551	but need to take into account that we might be at the end of the line before
2552	adding the space. */
2553	size_t offTodoAfter = offTodo + 4;
2554	if ( offTodoAfter < cchLine
2555	&& pchLine[offTodoAfter] == ':')
2556	offTodoAfter++;
2557	if ( offTodoAfter < cchLine
2558	&& RT_C_IS_BLANK(pchLine[offTodoAfter]))
2559	offTodoAfter++;
2560	if (offTodoAfter < cchLine)
2561	szNew[cchNew++] = ' ';
2562
2563	/* Write it out. */
2564	ScmStreamWrite(pOut, pchLine, offCommentStart);
2565	ScmStreamWrite(pOut, szNew, cchNew);
2566	if (offTodoAfter < cchLine)
2567	ScmStreamWrite(pOut, &pchLine[offTodoAfter], cchLine - offTodoAfter);
2568	ScmStreamPutEol(pOut, enmEol);
2569
2570	/* Check whether we actually made any changes. */
2571	if ( cchNew != offTodoAfter - offCommentStart
2572	\|\| memcmp(szNew, &pchLine[offCommentStart], cchNew))
2573	cChanges++;
2574	continue;
2575	}
2576	}
2577
2578	int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
2579	if (RT_FAILURE(rc))
2580	return false;
2581	}
2582	if (cChanges > 0)
2583	ScmVerbose(pState, 2, " * Converted %zu todo statements.\n", cChanges);
2584	return cChanges != 0;
2585	}
2586
2587
2588	/**
2589	* Tries to parse a C/C++ preprocessor include directive.
2590	*
2591	* This is resonably forgiving and expects sane input.
2592	*
2593	* @retval kScmIncludeDir_Invalid if not a valid include directive.
2594	* @retval kScmIncludeDir_Quoted
2595	* @retval kScmIncludeDir_Bracketed
2596	* @retval kScmIncludeDir_Macro
2597	*
2598	* @param pState The rewriter state (for repording malformed
2599	* directives).
2600	* @param pchLine The line to try parse as an include statement.
2601	* @param cchLine The line length.
2602	* @param ppchFilename Where to return the pointer to the filename part.
2603	* @param pcchFilename Where to return the length of the filename.
2604	*/
2605	SCMINCLUDEDIR ScmMaybeParseCIncludeLine(PSCMRWSTATE pState, const char *pchLine, size_t cchLine,
2606	const char *ppchFilename, size_t pcchFilename)
2607	{
2608	/* Skip leading spaces: */
2609	while (cchLine > 0 && RT_C_IS_BLANK(*pchLine))
2610	cchLine--, pchLine++;
2611
2612	/* Check for '#': */
2613	if (cchLine > 0 && *pchLine == '#')
2614	{
2615	cchLine--;
2616	pchLine++;
2617
2618	/* Skip spaces after '#' (optional): */
2619	while (cchLine > 0 && RT_C_IS_BLANK(*pchLine))
2620	cchLine--, pchLine++;
2621
2622	/* Check for 'include': */
2623	static char const s_szInclude[] = "include";
2624	if ( cchLine >= sizeof(s_szInclude)
2625	&& memcmp(pchLine, RT_STR_TUPLE(s_szInclude)) == 0)
2626	{
2627	cchLine -= sizeof(s_szInclude) - 1;
2628	pchLine += sizeof(s_szInclude) - 1;
2629
2630	/* Skip spaces after 'include' word (optional): */
2631	while (cchLine > 0 && RT_C_IS_BLANK(*pchLine))
2632	cchLine--, pchLine++;
2633	if (cchLine > 0)
2634	{
2635	/* Quoted or bracketed? */
2636	char const chFirst = *pchLine;
2637	if (chFirst == '"' \|\| chFirst == '<')
2638	{
2639	cchLine--;
2640	pchLine++;
2641	const char pchEnd = (const char )memchr(pchLine, chFirst == '"' ? '"' : '>', cchLine);
2642	if (pchEnd)
2643	{
2644	if (ppchFilename)
2645	*ppchFilename = pchLine;
2646	if (pcchFilename)
2647	*pcchFilename = pchEnd - pchLine;
2648	return chFirst == '"' ? kScmIncludeDir_Quoted : kScmIncludeDir_Bracketed;
2649	}
2650	ScmError(pState, VERR_PARSE_ERROR, "Unbalanced #include filename %s: %.*s\n",
2651	chFirst == '"' ? "quotes" : "brackets" , cchLine, pchLine);
2652	}
2653	/* C prepreprocessor macro? */
2654	else if (ScmIsCIdentifierLeadChar(chFirst))
2655	{
2656	size_t cchFilename = 1;
2657	while ( cchFilename < cchLine
2658	&& ScmIsCIdentifierChar(pchLine[cchFilename]))
2659	cchFilename++;
2660	if (ppchFilename)
2661	*ppchFilename = pchLine;
2662	if (pcchFilename)
2663	*pcchFilename = cchFilename;
2664	return kScmIncludeDir_Macro;
2665	}
2666	else
2667	ScmError(pState, VERR_PARSE_ERROR, "Malformed #include filename part: %.*s\n", cchLine, pchLine);
2668	}
2669	else
2670	ScmError(pState, VERR_PARSE_ERROR, "Missing #include filename!\n");
2671	}
2672	}
2673
2674	if (ppchFilename)
2675	*ppchFilename = NULL;
2676	if (pcchFilename)
2677	*pcchFilename = 0;
2678	return kScmIncludeDir_Invalid;
2679	}
2680
2681
2682	/**
2683	* Fix err.h/errcore.h usage.
2684	*
2685	* @returns true if modifications were made, false if not.
2686	* @param pIn The input stream.
2687	* @param pOut The output stream.
2688	* @param pSettings The settings.
2689	*/
2690	bool rewrite_Fix_Err_H(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2691	{
2692	if (!pSettings->fFixErrH)
2693	return false;
2694
2695	static struct
2696	{
2697	const char *pszHeader;
2698	unsigned cchHeader;
2699	int iLevel;
2700	} const s_aHeaders[] =
2701	{
2702	{ RT_STR_TUPLE("iprt/errcore.h"), 1 },
2703	{ RT_STR_TUPLE("iprt/err.h"), 2 },
2704	{ RT_STR_TUPLE("VBox/err.h"), 3 },
2705	};
2706	static RTSTRTUPLE const g_aLevel1Statuses[] = /* Note! Keep in sync with errcore.h content! */
2707	{
2708	{ RT_STR_TUPLE("VINF_SUCCESS") },
2709	{ RT_STR_TUPLE("VERR_GENERAL_FAILURE") },
2710	{ RT_STR_TUPLE("VERR_INVALID_PARAMETER") },
2711	{ RT_STR_TUPLE("VWRN_INVALID_PARAMETER") },
2712	{ RT_STR_TUPLE("VERR_INVALID_MAGIC") },
2713	{ RT_STR_TUPLE("VWRN_INVALID_MAGIC") },
2714	{ RT_STR_TUPLE("VERR_INVALID_HANDLE") },
2715	{ RT_STR_TUPLE("VWRN_INVALID_HANDLE") },
2716	{ RT_STR_TUPLE("VERR_INVALID_POINTER") },
2717	{ RT_STR_TUPLE("VERR_NO_MEMORY") },
2718	{ RT_STR_TUPLE("VERR_PERMISSION_DENIED") },
2719	{ RT_STR_TUPLE("VINF_PERMISSION_DENIED") },
2720	{ RT_STR_TUPLE("VERR_VERSION_MISMATCH") },
2721	{ RT_STR_TUPLE("VERR_NOT_IMPLEMENTED") },
2722	{ RT_STR_TUPLE("VERR_INVALID_FLAGS") },
2723	{ RT_STR_TUPLE("VERR_WRONG_ORDER") },
2724	{ RT_STR_TUPLE("VERR_INVALID_FUNCTION") },
2725	{ RT_STR_TUPLE("VERR_NOT_SUPPORTED") },
2726	{ RT_STR_TUPLE("VINF_NOT_SUPPORTED") },
2727	{ RT_STR_TUPLE("VERR_ACCESS_DENIED") },
2728	{ RT_STR_TUPLE("VERR_INTERRUPTED") },
2729	{ RT_STR_TUPLE("VINF_INTERRUPTED") },
2730	{ RT_STR_TUPLE("VERR_TIMEOUT") },
2731	{ RT_STR_TUPLE("VINF_TIMEOUT") },
2732	{ RT_STR_TUPLE("VERR_BUFFER_OVERFLOW") },
2733	{ RT_STR_TUPLE("VINF_BUFFER_OVERFLOW") },
2734	{ RT_STR_TUPLE("VERR_TOO_MUCH_DATA") },
2735	{ RT_STR_TUPLE("VERR_TRY_AGAIN") },
2736	{ RT_STR_TUPLE("VINF_TRY_AGAIN") },
2737	{ RT_STR_TUPLE("VERR_PARSE_ERROR") },
2738	{ RT_STR_TUPLE("VERR_OUT_OF_RANGE") },
2739	{ RT_STR_TUPLE("VERR_NUMBER_TOO_BIG") },
2740	{ RT_STR_TUPLE("VWRN_NUMBER_TOO_BIG") },
2741	{ RT_STR_TUPLE("VERR_CANCELLED") },
2742	{ RT_STR_TUPLE("VERR_TRAILING_CHARS") },
2743	{ RT_STR_TUPLE("VWRN_TRAILING_CHARS") },
2744	{ RT_STR_TUPLE("VERR_TRAILING_SPACES") },
2745	{ RT_STR_TUPLE("VWRN_TRAILING_SPACES") },
2746	{ RT_STR_TUPLE("VERR_NOT_FOUND") },
2747	{ RT_STR_TUPLE("VWRN_NOT_FOUND") },
2748	{ RT_STR_TUPLE("VERR_INVALID_STATE") },
2749	{ RT_STR_TUPLE("VWRN_INVALID_STATE") },
2750	{ RT_STR_TUPLE("VERR_OUT_OF_RESOURCES") },
2751	{ RT_STR_TUPLE("VWRN_OUT_OF_RESOURCES") },
2752	{ RT_STR_TUPLE("VERR_END_OF_STRING") },
2753	{ RT_STR_TUPLE("VERR_CALLBACK_RETURN") },
2754	{ RT_STR_TUPLE("VINF_CALLBACK_RETURN") },
2755	{ RT_STR_TUPLE("VERR_DUPLICATE") },
2756	{ RT_STR_TUPLE("VERR_MISSING") },
2757	{ RT_STR_TUPLE("VERR_BUFFER_UNDERFLOW") },
2758	{ RT_STR_TUPLE("VINF_BUFFER_UNDERFLOW") },
2759	{ RT_STR_TUPLE("VERR_NOT_AVAILABLE") },
2760	{ RT_STR_TUPLE("VERR_MISMATCH") },
2761	{ RT_STR_TUPLE("VERR_WRONG_TYPE") },
2762	{ RT_STR_TUPLE("VWRN_WRONG_TYPE") },
2763	{ RT_STR_TUPLE("VERR_WRONG_PARAMETER_COUNT") },
2764	{ RT_STR_TUPLE("VERR_WRONG_PARAMETER_TYPE") },
2765	{ RT_STR_TUPLE("VERR_INVALID_CLIENT_ID") },
2766	{ RT_STR_TUPLE("VERR_INVALID_SESSION_ID") },
2767	{ RT_STR_TUPLE("VERR_INCOMPATIBLE_CONFIG") },
2768	{ RT_STR_TUPLE("VERR_INTERNAL_ERROR") },
2769	{ RT_STR_TUPLE("VINF_GETOPT_NOT_OPTION") },
2770	{ RT_STR_TUPLE("VERR_GETOPT_UNKNOWN_OPTION") },
2771	};
2772
2773	/*
2774	* First pass: Scout #include err.h/errcore.h locations and usage.
2775	*
2776	* Note! This isn't entirely optimal since it's also parsing comments and
2777	* strings, not just code. However it does a decent job for now.
2778	*/
2779	int iIncludeLevel = 0;
2780	int iUsageLevel = 0;
2781	uint32_t iLine = 0;
2782	SCMEOL enmEol;
2783	size_t cchLine;
2784	const char *pchLine;
2785	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
2786	{
2787	iLine++;
2788	if (cchLine < 6)
2789	continue;
2790
2791	/*
2792	* Look for #includes.
2793	*/
2794	const char pchHash = (const char )memchr(pchLine, '#', cchLine);
2795	if ( pchHash
2796	&& isSpanOfBlanks(pchLine, pchHash - pchLine))
2797	{
2798	const char *pchFilename;
2799	size_t cchFilename;
2800	SCMINCLUDEDIR enmIncDir = ScmMaybeParseCIncludeLine(pState, pchLine, cchLine, &pchFilename, &cchFilename);
2801	if ( enmIncDir == kScmIncludeDir_Bracketed
2802	\|\| enmIncDir == kScmIncludeDir_Quoted)
2803	{
2804	unsigned i = RT_ELEMENTS(s_aHeaders);
2805	while (i-- > 0)
2806	if ( s_aHeaders[i].cchHeader == cchFilename
2807	&& RTStrNICmpAscii(pchFilename, s_aHeaders[i].pszHeader, cchFilename) == 0)
2808	{
2809	if (iIncludeLevel < s_aHeaders[i].iLevel)
2810	iIncludeLevel = s_aHeaders[i].iLevel;
2811	break;
2812	}
2813
2814	/* Special hack for error info. */
2815	if (cchFilename == sizeof("errmsgdata.h") - 1 && memcmp(pchFilename, RT_STR_TUPLE("errmsgdata.h")) == 0)
2816	iUsageLevel = 4;
2817
2818	/* Special hack for code templates. */
2819	if ( cchFilename >= sizeof(".cpp.h")
2820	&& memcmp(&pchFilename[cchFilename - sizeof(".cpp.h") + 1], RT_STR_TUPLE(".cpp.h")) == 0)
2821	iUsageLevel = 4;
2822	continue;
2823	}
2824	}
2825	/*
2826	* Look for VERR_, VWRN_, VINF_ prefixed identifiers in the current line.
2827	*/
2828	const char pchHit = (const char )memchr(pchLine, 'V', cchLine);
2829	if (pchHit)
2830	{
2831	const char *pchLeft = pchLine;
2832	size_t cchLeft = cchLine;
2833	do
2834	{
2835	size_t cchLeftHit = &pchLeft[cchLeft] - pchHit;
2836	if (cchLeftHit < 6)
2837	break;
2838	if ( pchHit[4] == '_'
2839	&& ( pchHit == pchLine
2840	\|\| !ScmIsCIdentifierChar(pchHit[-1]))
2841	&& ( (pchHit[1] == 'E' && pchHit[2] == 'R' && pchHit[3] == 'R')
2842	\|\| (pchHit[1] == 'W' && pchHit[2] == 'R' && pchHit[3] == 'N')
2843	\|\| (pchHit[1] == 'I' && pchHit[2] == 'N' && pchHit[3] == 'F') ) )
2844	{
2845	size_t cchIdentifier = 5;
2846	while (cchIdentifier < cchLeftHit && ScmIsCIdentifierChar(pchHit[cchIdentifier]))
2847	cchIdentifier++;
2848	ScmVerbose(pState, 4, "--- status code at %u col %zu: %.*s\n",
2849	iLine, pchHit - pchLine, cchIdentifier, pchHit);
2850
2851	if (iUsageLevel <= 1)
2852	{
2853	iUsageLevel = 3; /* Cannot distingish between iprt/err.h and VBox/err.h, so pick the latter for now. */
2854	for (unsigned i = 0; i < RT_ELEMENTS(g_aLevel1Statuses); i++)
2855	if ( cchIdentifier == g_aLevel1Statuses[i].cch
2856	&& memcmp(pchHit, g_aLevel1Statuses[i].psz, cchIdentifier) == 0)
2857	{
2858	iUsageLevel = 1;
2859	break;
2860	}
2861	}
2862
2863	pchLeft = pchHit + cchIdentifier;
2864	cchLeft = cchLeftHit - cchIdentifier;
2865	}
2866	else
2867	{
2868	pchLeft = pchHit + 1;
2869	cchLeft = cchLeftHit - 1;
2870	}
2871	pchHit = (const char *)memchr(pchLeft, 'V', cchLeft);
2872	} while (pchHit != NULL);
2873	}
2874	}
2875	ScmVerbose(pState, 3, "--- iIncludeLevel=%d iUsageLevel=%d\n", iIncludeLevel, iUsageLevel);
2876
2877	/*
2878	* Second pass: Change err.h to errcore.h if we detected a need for change.
2879	*/
2880	if ( iIncludeLevel <= iUsageLevel
2881	\|\| iIncludeLevel <= 1 /* we cannot safely eliminate errcore.h includes atm. */)
2882	return false;
2883
2884	unsigned cChanges = 0;
2885	ScmStreamRewindForReading(pIn);
2886	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
2887	{
2888	/*
2889	* Look for #includes to modify.
2890	*/
2891	if (cchLine >= 6)
2892	{
2893	const char pchHash = (const char )memchr(pchLine, '#', cchLine);
2894	if ( pchHash
2895	&& isSpanOfBlanks(pchLine, pchHash - pchLine))
2896	{
2897	const char *pchFilename;
2898	size_t cchFilename;
2899	SCMINCLUDEDIR enmIncDir = ScmMaybeParseCIncludeLine(pState, pchLine, cchLine, &pchFilename, &cchFilename);
2900	if ( enmIncDir == kScmIncludeDir_Bracketed
2901	\|\| enmIncDir == kScmIncludeDir_Quoted)
2902	{
2903	unsigned i = RT_ELEMENTS(s_aHeaders);
2904	while (i-- > 0)
2905	if ( s_aHeaders[i].cchHeader == cchFilename
2906	&& RTStrNICmpAscii(pchFilename, s_aHeaders[i].pszHeader, cchFilename) == 0)
2907	{
2908	ScmStreamWrite(pOut, pchLine, pchFilename - pchLine - 1);
2909	ScmStreamWrite(pOut, RT_STR_TUPLE("<iprt/errcore.h>"));
2910	size_t cchTrailing = &pchLine[cchLine] - &pchFilename[cchFilename + 1];
2911	if (cchTrailing > 0)
2912	ScmStreamWrite(pOut, &pchFilename[cchFilename + 1], cchTrailing);
2913	ScmStreamPutEol(pOut, enmEol);
2914	cChanges++;
2915	pchLine = NULL;
2916	break;
2917	}
2918	if (!pchLine)
2919	continue;
2920	}
2921	}
2922	}
2923
2924	int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
2925	if (RT_FAILURE(rc))
2926	return false;
2927	}
2928	ScmVerbose(pState, 2, " * Converted %zu err.h/errcore.h include statements.\n", cChanges);
2929	return true;
2930	}
2931
2932	typedef struct
2933	{
2934	const char *pch;
2935	uint8_t cch;
2936	uint8_t cchSpaces; /*< Number of expected spaces before the word. /
2937	bool fSpacesBefore : 1; /*< Whether there may be spaces or tabs before the word. /
2938	bool fIdentifier : 1; /*< Whether we're to expect a C/C++ identifier rather than pch/cch. /
2939	} SCMMATCHWORD;
2940
2941
2942	int ScmMatchWords(const char pchLine, size_t cchLine, SCMMATCHWORD const paWords, size_t cWords,
2943	size_t *poffNext, PRTSTRTUPLE paIdentifiers, PRTERRINFO pErrInfo)
2944	{
2945	int rc = VINF_SUCCESS;
2946
2947	size_t offLine = 0;
2948	for (size_t i = 0; i < cWords; i++)
2949	{
2950	SCMMATCHWORD const *pWord = &paWords[i];
2951
2952	/*
2953	* Deal with spaces preceeding the word first:
2954	*/
2955	if (pWord->fSpacesBefore)
2956	{
2957	size_t cchSpaces = 0;
2958	size_t cchTabs = 0;
2959	while (offLine < cchLine)
2960	{
2961	const char ch = pchLine[offLine];
2962	if (ch == ' ')
2963	cchSpaces++;
2964	else if (ch == '\t')
2965	cchTabs++;
2966	else
2967	break;
2968	offLine++;
2969	}
2970
2971	if (cchSpaces == pWord->cchSpaces && cchTabs == 0)
2972	{ /* likely */ }
2973	else if (cchSpaces == 0 && cchTabs == 0)
2974	return RTErrInfoSetF(pErrInfo, VERR_PARSE_ERROR, "expected space at offset %u", offLine);
2975	else
2976	rc = VWRN_TRAILING_SPACES;
2977	}
2978	else
2979	Assert(pWord->cchSpaces == 0);
2980
2981	/*
2982	* C/C++ identifier?
2983	*/
2984	if (pWord->fIdentifier)
2985	{
2986	if (offLine >= cchLine)
2987	return RTErrInfoSetF(pErrInfo, VERR_END_OF_STRING,
2988	"expected '%.*s' (C/C++ identifier) at offset %u, not end of string",
2989	pWord->cch, pWord->pch, offLine);
2990	if (!ScmIsCIdentifierLeadChar(pchLine[offLine]))
2991	return RTErrInfoSetF(pErrInfo, VERR_MISMATCH, "expected '%.*s' (C/C++ identifier) at offset %u",
2992	pWord->cch, pWord->pch, offLine);
2993	size_t const offStart = offLine++;
2994	while (offLine < cchLine && ScmIsCIdentifierChar(pchLine[offLine]))
2995	offLine++;
2996	if (paIdentifiers)
2997	{
2998	paIdentifiers->cch = offLine - offStart;
2999	paIdentifiers->psz = &pchLine[offStart];
3000	paIdentifiers++;
3001	}
3002	}
3003	/*
3004	* Match the exact word.
3005	*/
3006	else if ( pWord->cch == 0
3007	\|\| ( pWord->cch <= cchLine - offLine
3008	&& !memcmp(pWord->pch, &pchLine[offLine], pWord->cch)))
3009	offLine += pWord->cch;
3010	else
3011	return RTErrInfoSetF(pErrInfo, VERR_MISMATCH, "expected '%.*s' at offset %u", pWord->cch, pWord->pch, offLine);
3012	}
3013
3014	/*
3015	* Check for trailing characters/whatnot.
3016	*/
3017	if (poffNext)
3018	*poffNext = offLine;
3019	else if (offLine != cchLine)
3020	rc = RTErrInfoSetF(pErrInfo, VERR_TRAILING_CHARS, "unexpected trailing characters at offset %u", offLine);
3021	return rc;
3022	}
3023
3024
3025	/**
3026	* Fix header file include guards and \#pragma once.
3027	*
3028	* @returns true if modifications were made, false if not.
3029	* @param pIn The input stream.
3030	* @param pOut The output stream.
3031	* @param pSettings The settings.
3032	*/
3033	bool rewrite_FixHeaderGuards(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
3034	{
3035	if (!pSettings->fFixHeaderGuards)
3036	return false;
3037
3038	/* always skip .cpp.h files */
3039	size_t cchFilename = strlen(pState->pszFilename);
3040	if ( cchFilename > sizeof(".cpp.h")
3041	&& RTStrICmpAscii(&pState->pszFilename[cchFilename - sizeof(".cpp.h") + 1], ".cpp.h") == 0)
3042	return false;
3043
3044	RTERRINFOSTATIC ErrInfo;
3045	char szNormalized[168];
3046	size_t cchNormalized = 0;
3047	int rc;
3048	bool fRet = false;
3049
3050	/*
3051	* Calculate the expected guard for this file, if so tasked.
3052	* ASSUMES pState->pszFilename is absolute as is pSettings->pszGuardRelativeToDir.
3053	*/
3054	szNormalized[0] = '\0';
3055	if (pSettings->pszGuardRelativeToDir)
3056	{
3057	rc = RTStrCopy(szNormalized, sizeof(szNormalized), pSettings->pszGuardPrefix);
3058	if (RT_FAILURE(rc))
3059	return ScmError(pState, rc, "Guard prefix too long (or something): %s\n", pSettings->pszGuardPrefix);
3060	cchNormalized = strlen(szNormalized);
3061	if (strcmp(pSettings->pszGuardRelativeToDir, "{dir}") == 0)
3062	rc = RTStrCopy(&szNormalized[cchNormalized], sizeof(szNormalized) - cchNormalized,
3063	RTPathFilename(pState->pszFilename));
3064	else if (strcmp(pSettings->pszGuardRelativeToDir, "{parent}") == 0)
3065	{
3066	const char *pszSrc = RTPathFilename(pState->pszFilename);
3067	if (!pszSrc \|\| (uintptr_t)&pszSrc[-2] < (uintptr_t)pState->pszFilename \|\| !RTPATH_IS_SLASH(pszSrc[-1]))
3068	return ScmError(pState, VERR_INTERNAL_ERROR, "Error calculating {parent} header guard!\n");
3069	pszSrc -= 2;
3070	while ( (uintptr_t)pszSrc > (uintptr_t)pState->pszFilename
3071	&& !RTPATH_IS_SLASH(pszSrc[-1])
3072	&& !RTPATH_IS_VOLSEP(pszSrc[-1]))
3073	pszSrc--;
3074	rc = RTStrCopy(&szNormalized[cchNormalized], sizeof(szNormalized) - cchNormalized, pszSrc);
3075	}
3076	else
3077	rc = RTPathCalcRelative(&szNormalized[cchNormalized], sizeof(szNormalized) - cchNormalized,
3078	pSettings->pszGuardRelativeToDir, false /fFromFile/, pState->pszFilename);
3079	if (RT_FAILURE(rc))
3080	return ScmError(pState, rc, "Error calculating guard prefix (RTPathCalcRelative): %Rrc\n", rc);
3081	char ch;
3082	while ((ch = szNormalized[cchNormalized]) != '\0')
3083	{
3084	if (!ScmIsCIdentifierChar(ch))
3085	szNormalized[cchNormalized] = '_';
3086	cchNormalized++;
3087	}
3088	}
3089
3090	/*
3091	* First part looks for the #ifndef xxxx paired with #define xxxx.
3092	*
3093	* We blindly assume the first preprocessor directive in the file is the guard
3094	* and will be upset if this isn't the case.
3095	*/
3096	RTSTRTUPLE Guard = { NULL, 0 };
3097	uint32_t cBlankLines = 0;
3098	SCMEOL enmEol;
3099	size_t cchLine;
3100	const char *pchLine;
3101	for (;;)
3102	{
3103	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
3104	if (pchLine == NULL)
3105	return ScmError(pState, VERR_PARSE_ERROR, "Did not find any include guards!\n");
3106	if (cchLine >= 2)
3107	{
3108	const char pchHash = (const char )memchr(pchLine, '#', cchLine);
3109	if ( pchHash
3110	&& isSpanOfBlanks(pchLine, pchHash - pchLine))
3111	{
3112	/* #ifndef xxxx */
3113	static const SCMMATCHWORD s_aIfndefGuard[] =
3114	{
3115	{ RT_STR_TUPLE("#"), 0, true, false },
3116	{ RT_STR_TUPLE("ifndef"), 0, true, false },
3117	{ RT_STR_TUPLE("IDENTIFIER"), 1, true, true },
3118	{ RT_STR_TUPLE(""), 0, true, false },
3119	};
3120	rc = ScmMatchWords(pchLine, cchLine, s_aIfndefGuard, RT_ELEMENTS(s_aIfndefGuard),
3121	NULL /poffNext/, &Guard, RTErrInfoInitStatic(&ErrInfo));
3122	if (RT_FAILURE(rc))
3123	return ScmError(pState, rc, "%u: Expected first preprocessor directive to be '#ifndef xxxx'. %s (%.*s)\n",
3124	ScmStreamTellLine(pIn) - 1, ErrInfo.Core.pszMsg, cchLine, pchLine);
3125	fRet \|= rc != VINF_SUCCESS;
3126	ScmVerbose(pState, 3, "line %u in %s: #ifndef %.*s\n",
3127	ScmStreamTellLine(pIn) - 1, pState->pszFilename, Guard.cch, Guard.psz);
3128
3129	/* #define xxxx */
3130	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
3131	if (!pchLine)
3132	return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after '#ifndef %.*s'\n",
3133	ScmStreamTellLine(pIn) - 1, Guard.cch, Guard.psz);
3134	const SCMMATCHWORD aDefineGuard[] =
3135	{
3136	{ RT_STR_TUPLE("#"), 0, true, false },
3137	{ RT_STR_TUPLE("define"), 0, true, false },
3138	{ Guard.psz, (uint8_t)Guard.cch, 1, true, false },
3139	{ RT_STR_TUPLE(""), 0, true, false },
3140	};
3141	rc = ScmMatchWords(pchLine, cchLine, aDefineGuard, RT_ELEMENTS(aDefineGuard),
3142	NULL /poffNext/, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3143	if (RT_FAILURE(rc))
3144	return ScmError(pState, rc, "%u: Expected '#define %.s' to follow '#ifndef %.s'. %s (%.*s)\n",
3145	ScmStreamTellLine(pIn) - 1, Guard.cch, Guard.psz, Guard.cch, Guard.psz,
3146	ErrInfo.Core.pszMsg, cchLine, pchLine);
3147	fRet \|= rc != VINF_SUCCESS;
3148
3149	if (Guard.cch >= sizeof(szNormalized))
3150	return ScmError(pState, VERR_BUFFER_OVERFLOW, "%u: Guard macro too long! %.*s\n",
3151	ScmStreamTellLine(pIn) - 2, Guard.cch, Guard.psz);
3152
3153	if (szNormalized[0] != '\0')
3154	{
3155	if ( Guard.cch != cchNormalized
3156	\|\| memcmp(Guard.psz, szNormalized, cchNormalized) != 0)
3157	{
3158	ScmVerbose(pState, 2, "guard changed from %.*s to %s\n", Guard.cch, Guard.psz, szNormalized);
3159	ScmVerbose(pState, 2, "grep -rw %.*s ${WCROOT} \| grep -Fv %s\n",
3160	Guard.cch, Guard.psz, pState->pszFilename);
3161	fRet = true;
3162	}
3163	Guard.psz = szNormalized;
3164	Guard.cch = cchNormalized;
3165	}
3166
3167	/*
3168	* Write guard, making sure we've got a single blank line preceeding it.
3169	*/
3170	ScmStreamPutEol(pOut, enmEol);
3171	ScmStreamWrite(pOut, RT_STR_TUPLE("#ifndef "));
3172	ScmStreamWrite(pOut, Guard.psz, Guard.cch);
3173	ScmStreamPutEol(pOut, enmEol);
3174	ScmStreamWrite(pOut, RT_STR_TUPLE("#define "));
3175	ScmStreamWrite(pOut, Guard.psz, Guard.cch);
3176	rc = ScmStreamPutEol(pOut, enmEol);
3177	if (RT_FAILURE(rc))
3178	return false;
3179	break;
3180	}
3181	}
3182
3183	if (!isBlankLine(pchLine, cchLine))
3184	{
3185	while (cBlankLines-- > 0)
3186	ScmStreamPutEol(pOut, enmEol);
3187	cBlankLines = 0;
3188	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
3189	if (RT_FAILURE(rc))
3190	return false;
3191	}
3192	else
3193	cBlankLines++;
3194	}
3195
3196	/*
3197	* Look for pragma once wrapped in #ifndef RT_WITHOUT_PRAGMA_ONCE.
3198	*/
3199	size_t const iPragmaOnce = ScmStreamTellLine(pIn);
3200	static const SCMMATCHWORD s_aIfndefRtWithoutPragmaOnce[] =
3201	{
3202	{ RT_STR_TUPLE("#"), 0, true, false },
3203	{ RT_STR_TUPLE("ifndef"), 0, true, false },
3204	{ RT_STR_TUPLE("RT_WITHOUT_PRAGMA_ONCE"), 1, true, false },
3205	{ RT_STR_TUPLE(""), 0, true, false },
3206	};
3207	static const SCMMATCHWORD s_aPragmaOnce[] =
3208	{
3209	{ RT_STR_TUPLE("#"), 0, true, false },
3210	{ RT_STR_TUPLE("pragma"), 1, true, false },
3211	{ RT_STR_TUPLE("once"), 1, true, false},
3212	{ RT_STR_TUPLE(""), 0, true, false },
3213	};
3214	static const SCMMATCHWORD s_aEndif[] =
3215	{
3216	{ RT_STR_TUPLE("#"), 0, true, false },
3217	{ RT_STR_TUPLE("endif"), 0, true, false },
3218	{ RT_STR_TUPLE(""), 0, true, false },
3219	};
3220
3221	/* #ifndef RT_WITHOUT_PRAGMA_ONCE */
3222	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
3223	if (!pchLine)
3224	return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after header guard!\n", iPragmaOnce + 1);
3225	size_t offNext;
3226	rc = ScmMatchWords(pchLine, cchLine, s_aIfndefRtWithoutPragmaOnce, RT_ELEMENTS(s_aIfndefRtWithoutPragmaOnce),
3227	&offNext, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3228	if (RT_SUCCESS(rc))
3229	{
3230	fRet \|= rc != VINF_SUCCESS;
3231	if (offNext != cchLine)
3232	return ScmError(pState, VERR_PARSE_ERROR, "%u: Characters trailing '#ifndef RT_WITHOUT_PRAGMA_ONCE' (%.*s)\n",
3233	iPragmaOnce + 1, cchLine, pchLine);
3234
3235	/* # pragma once */
3236	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
3237	if (!pchLine)
3238	return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after '#ifndef RT_WITHOUT_PRAGMA_ONCE'\n",
3239	iPragmaOnce + 2);
3240	rc = ScmMatchWords(pchLine, cchLine, s_aPragmaOnce, RT_ELEMENTS(s_aPragmaOnce),
3241	NULL /poffNext/, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3242	if (RT_SUCCESS(rc))
3243	fRet \|= rc != VINF_SUCCESS;
3244	else
3245	return ScmError(pState, rc, "%u: Expected '# pragma once' to follow '#ifndef RT_WITHOUT_PRAGMA_ONCE'! %s (%.*s)\n",
3246	iPragmaOnce + 2, ErrInfo.Core.pszMsg, cchLine, pchLine);
3247
3248	/* #endif */
3249	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
3250	if (!pchLine)
3251	return ScmError(pState, VERR_PARSE_ERROR, "%u: Unexpected end of file after '#ifndef RT_WITHOUT_PRAGMA_ONCE' and '#pragma once'\n",
3252	iPragmaOnce + 3);
3253	rc = ScmMatchWords(pchLine, cchLine, s_aEndif, RT_ELEMENTS(s_aEndif),
3254	NULL /poffNext/, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3255	if (RT_SUCCESS(rc))
3256	fRet \|= rc != VINF_SUCCESS;
3257	else
3258	return ScmError(pState, rc,
3259	"%u: Expected '#endif' to follow '#ifndef RT_WITHOUT_PRAGMA_ONCE' and '# pragma once'! %s (%.*s)\n",
3260	iPragmaOnce + 3, ErrInfo.Core.pszMsg, cchLine, pchLine);
3261	ScmVerbose(pState, 3, "Found pragma once\n");
3262	fRet \|= !pSettings->fPragmaOnce;
3263	}
3264	else
3265	{
3266	rc = ScmStreamSeekByLine(pIn, iPragmaOnce);
3267	if (RT_FAILURE(rc))
3268	return ScmError(pState, rc, "seek error\n");
3269	fRet \|= pSettings->fPragmaOnce;
3270	ScmVerbose(pState, pSettings->fPragmaOnce ? 2 : 3, "Missing #pragma once\n");
3271	}
3272
3273	/*
3274	* Write the pragma once stuff.
3275	*/
3276	if (pSettings->fPragmaOnce)
3277	{
3278	ScmStreamPutLine(pOut, RT_STR_TUPLE("#ifndef RT_WITHOUT_PRAGMA_ONCE"), enmEol);
3279	ScmStreamPutLine(pOut, RT_STR_TUPLE("# pragma once"), enmEol);
3280	rc = ScmStreamPutLine(pOut, RT_STR_TUPLE("#endif"), enmEol);
3281	if (RT_FAILURE(rc))
3282	return false;
3283	}
3284
3285	/*
3286	* Copy the rest of the file and remove pragma once statements, while
3287	* looking for the last #endif in the file.
3288	*/
3289	size_t iEndIfIn = 0;
3290	size_t iEndIfOut = 0;
3291	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
3292	{
3293	if (cchLine > 2)
3294	{
3295	const char pchHash = (const char )memchr(pchLine, '#', cchLine);
3296	if ( pchHash
3297	&& isSpanOfBlanks(pchLine, pchHash - pchLine))
3298	{
3299	size_t off = pchHash - pchLine + 1;
3300	while (off < cchLine && RT_C_IS_BLANK(pchLine[off]))
3301	off++;
3302	/* #pragma once */
3303	if ( off + sizeof("pragma") - 1 <= cchLine
3304	&& !memcmp(&pchLine[off], RT_STR_TUPLE("pragma")))
3305	{
3306	rc = ScmMatchWords(pchLine, cchLine, s_aPragmaOnce, RT_ELEMENTS(s_aPragmaOnce),
3307	&offNext, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3308	if (RT_SUCCESS(rc))
3309	{
3310	fRet = true;
3311	continue;
3312	}
3313	}
3314	/* #endif */
3315	else if ( off + sizeof("endif") - 1 <= cchLine
3316	&& !memcmp(&pchLine[off], RT_STR_TUPLE("endif")))
3317	{
3318	iEndIfIn = ScmStreamTellLine(pIn) - 1;
3319	iEndIfOut = ScmStreamTellLine(pOut);
3320	}
3321	}
3322	}
3323
3324	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
3325	if (RT_FAILURE(rc))
3326	return false;
3327	}
3328
3329	/*
3330	* Check out the last endif, making sure it's well formed and make sure it has the
3331	* right kind of comment following it.
3332	*/
3333	if (pSettings->fFixHeaderGuardEndif)
3334	{
3335	if (iEndIfOut == 0)
3336	return ScmError(pState, VERR_PARSE_ERROR, "Expected '#endif' at the end of the file...\n");
3337	rc = ScmStreamSeekByLine(pIn, iEndIfIn);
3338	if (RT_FAILURE(rc))
3339	return false;
3340	rc = ScmStreamSeekByLine(pOut, iEndIfOut);
3341	if (RT_FAILURE(rc))
3342	return false;
3343
3344	pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
3345	if (!pchLine)
3346	return ScmError(pState, VERR_INTERNAL_ERROR, "ScmStreamGetLine failed re-reading #endif!\n");
3347
3348	char szTmp[64 + sizeof(szNormalized)];
3349	size_t cchTmp;
3350	if (pSettings->fEndifGuardComment)
3351	cchTmp = RTStrPrintf(szTmp, sizeof(szTmp), "#endif /* !%.s /", Guard.cch, Guard.psz);
3352	else
3353	cchTmp = RTStrPrintf(szTmp, sizeof(szTmp), "#endif"); /* lazy bird */
3354	fRet \|= cchTmp != cchLine \|\| memcmp(szTmp, pchLine, cchTmp) != 0;
3355	rc = ScmStreamPutLine(pOut, szTmp, cchTmp, enmEol);
3356	if (RT_FAILURE(rc))
3357	return false;
3358
3359	/* Copy out the remaining lines (assumes no #pragma once here). */
3360	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
3361	{
3362	rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
3363	if (RT_FAILURE(rc))
3364	return false;
3365	}
3366	}
3367
3368	return fRet;
3369	}
3370
3371
3372	/**
3373	* Checks for PAGE_SIZE, PAGE_SHIFT and PAGE_OFFSET_MASK w/o a GUEST_ or HOST_
3374	* prefix as well as banning PAGE_BASE_HC_MASK, PAGE_BASE_GC_MASK and
3375	* PAGE_BASE_MASK.
3376	*
3377	* @returns true if modifications were made, false if not.
3378	* @param pIn The input stream.
3379	* @param pOut The output stream.
3380	* @param pSettings The settings.
3381	*/
3382	bool rewrite_PageChecks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
3383	{
3384	RT_NOREF(pOut);
3385	if (!pSettings->fOnlyGuestHostPage && !pSettings->fNoASMMemPageUse)
3386	return false;
3387
3388	static RTSTRTUPLE const g_aWords[] =
3389	{
3390	{ RT_STR_TUPLE("PAGE_SIZE") },
3391	{ RT_STR_TUPLE("PAGE_SHIFT") },
3392	{ RT_STR_TUPLE("PAGE_OFFSET_MASK") },
3393	{ RT_STR_TUPLE("PAGE_BASE_MASK") },
3394	{ RT_STR_TUPLE("PAGE_BASE_GC_MASK") },
3395	{ RT_STR_TUPLE("PAGE_BASE_HC_MASK") },
3396	{ RT_STR_TUPLE("PAGE_ADDRESS") },
3397	{ RT_STR_TUPLE("PHYS_PAGE_ADDRESS") },
3398	{ RT_STR_TUPLE("ASMMemIsZeroPage") },
3399	{ RT_STR_TUPLE("ASMMemZeroPage") },
3400	};
3401	size_t const iFirstWord = pSettings->fOnlyGuestHostPage ? 0 : 7;
3402	size_t const iEndWords = pSettings->fNoASMMemPageUse ? 9 : 7;
3403
3404	uint32_t iLine = 0;
3405	SCMEOL enmEol;
3406	size_t cchLine;
3407	const char *pchLine;
3408	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
3409	{
3410	iLine++;
3411	for (size_t i = iFirstWord; i < iEndWords; i++)
3412	{
3413	size_t const cchWord = g_aWords[i].cch;
3414	if (cchLine >= cchWord)
3415	{
3416	const char * const pszWord = g_aWords[i].psz;
3417	const char pchHit = (const char )memchr(pchLine, *pszWord, cchLine);
3418	while (pchHit)
3419	{
3420	size_t cchLeft = (uintptr_t)&pchLine[cchLine] - (uintptr_t)pchHit;
3421	if ( cchLeft >= cchWord
3422	&& memcmp(pchHit, pszWord, cchWord) == 0
3423	&& ( pchHit == pchLine
3424	\|\| !ScmIsCIdentifierChar(pchHit[-1]))
3425	&& ( cchLeft == cchWord
3426	\|\| !ScmIsCIdentifierChar(pchHit[cchWord])) )
3427	{
3428	if (i < 3)
3429	ScmFixManually(pState, "%u:%zu: %s is not allow! Use GUEST_%s or HOST_%s instead.\n",
3430	iLine, pchHit - pchLine + 1, pszWord, pszWord, pszWord);
3431	else if (i < 7)
3432	ScmFixManually(pState, "%u:%zu: %s is not allow! Rewrite using GUEST/HOST_PAGE_OFFSET_MASK.\n",
3433	iLine, pchHit - pchLine + 1, pszWord);
3434	else
3435	ScmFixManually(pState, "%u:%zu: %s is not allow! Use %s with correct page size instead.\n",
3436	iLine, pchHit - pchLine + 1, pszWord, i == 3 ? "ASMMemIsZero" : "RT_BZERO");
3437	}
3438
3439	/* next */
3440	cchLeft -= 1;
3441	if (cchLeft < cchWord)
3442	break;
3443	pchHit = (const char )memchr(pchHit + 1, pszWord, cchLeft);
3444	}
3445	}
3446	}
3447	}
3448
3449	return false;
3450	}
3451
3452
3453	/**
3454	* Checks for usage of rc in code instead of vrc for IPRT status codes (int) and hrc for COM
3455	* status codes (HRESULT).
3456	*
3457	* @returns true if modifications were made, false if not.
3458	* @param pIn The input stream.
3459	* @param pOut The output stream.
3460	* @param pSettings The settings.
3461	*
3462	* @note Used in Main to avoid ambiguity when just using rc.
3463	*/
3464	bool rewrite_ForceHrcVrcInsteadOfRc(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
3465	{
3466	RT_NOREF(pOut);
3467	if (!pSettings->fOnlyHrcVrcInsteadOfRc)
3468	return false;
3469
3470	static const SCMMATCHWORD s_aHresultVrc[] =
3471	{
3472	{ RT_STR_TUPLE("HRESULT"), 0, true, false },
3473	{ RT_STR_TUPLE("vrc"), 1, true, false }
3474	};
3475
3476	static const SCMMATCHWORD s_aIntHrc[] =
3477	{
3478	{ RT_STR_TUPLE("int"), 0, true, false },
3479	{ RT_STR_TUPLE("hrc"), 1, true, false }
3480	};
3481
3482	uint32_t iLine = 0;
3483	SCMEOL enmEol;
3484	size_t cchLine;
3485	const char *pchLine;
3486	RTERRINFOSTATIC ErrInfo;
3487	while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
3488	{
3489	iLine++;
3490
3491	/* Look for forbidden declarations first. */
3492	size_t offNext = 0;
3493	int rc = ScmMatchWords(pchLine, cchLine, s_aHresultVrc, RT_ELEMENTS(s_aHresultVrc),
3494	&offNext, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3495	if (RT_SUCCESS(rc))
3496	{
3497	ScmFixManually(pState, "%u:%zu: 'HRESULT vrc' is not allowed! Use 'HRESULT hrc' instead.\n",
3498	iLine, offNext);
3499	continue;
3500	}
3501
3502	rc = ScmMatchWords(pchLine, cchLine, s_aIntHrc, RT_ELEMENTS(s_aIntHrc),
3503	&offNext, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3504	if (RT_SUCCESS(rc))
3505	{
3506	ScmFixManually(pState, "%u:%zu: 'int hrc' is not allowed! Use 'int vrc' instead.\n",
3507	iLine, offNext);
3508	continue;
3509	}
3510
3511	#if 0 /* This is too broad and triggers on things we don't want to trigger on (like autoCaller.rc()). */
3512	const RTSTRTUPLE RcTuple = { RT_STR_TUPLE("rc") };
3513	size_t const cchWord = RcTuple.cch;
3514	if (cchLine >= cchWord)
3515	{
3516	const char pchHit = (const char )memchr(pchLine, *RcTuple.psz, cchLine);
3517	while (pchHit)
3518	{
3519	size_t cchLeft = (uintptr_t)&pchLine[cchLine] - (uintptr_t)pchHit;
3520	if ( cchLeft >= cchWord
3521	&& memcmp(pchHit, RcTuple.psz, cchWord) == 0
3522	&& ( pchHit == pchLine
3523	\|\| !ScmIsCIdentifierChar(pchHit[-1]))
3524	&& ( cchLeft == cchWord
3525	\|\| !ScmIsCIdentifierChar(pchHit[cchWord])) )
3526	ScmFixManually(pState, "%u:%zu: %s is not allowed! Use hrc or vrc instead.\n",
3527	iLine, pchHit - pchLine + 1, RcTuple.psz);
3528
3529	/* next */
3530	cchLeft -= 1;
3531	if (cchLeft < cchWord)
3532	break;
3533	pchHit = (const char )memchr(pchHit + 1, RcTuple.psz, cchLeft);
3534	}
3535	}
3536	#else
3537	/* Trigger on declarations of 'HRESULT rc' and 'int rc'. */
3538	static const SCMMATCHWORD s_aHresultRc[] =
3539	{
3540	{ RT_STR_TUPLE("HRESULT"), 0, true, false },
3541	{ RT_STR_TUPLE("rc"), 1, true, false }
3542	};
3543
3544	static const SCMMATCHWORD s_aIntRc[] =
3545	{
3546	{ RT_STR_TUPLE("int"), 0, true, false },
3547	{ RT_STR_TUPLE("rc"), 1, true, false }
3548	};
3549
3550	rc = ScmMatchWords(pchLine, cchLine, s_aHresultRc, RT_ELEMENTS(s_aHresultRc),
3551	&offNext, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3552	if (RT_SUCCESS(rc))
3553	{
3554	ScmFixManually(pState, "%u:%zu: 'HRESULT rc' is not allowed! Use 'HRESULT hrc' instead.\n",
3555	iLine, offNext);
3556	continue;
3557	}
3558
3559	rc = ScmMatchWords(pchLine, cchLine, s_aIntRc, RT_ELEMENTS(s_aIntRc),
3560	&offNext, NULL /paIdentifiers/, RTErrInfoInitStatic(&ErrInfo));
3561	if (RT_SUCCESS(rc))
3562	{
3563	ScmFixManually(pState, "%u:%zu: 'int rc' is not allowed! Use 'int vrc' instead.\n",
3564	iLine, offNext);
3565	continue;
3566	}
3567	#endif
3568	}
3569
3570	return false;
3571	}
3572
3573
3574	/**
3575	* Rewrite a C/C++ source or header file.
3576	*
3577	* @returns true if modifications were made, false if not.
3578	* @param pIn The input stream.
3579	* @param pOut The output stream.
3580	* @param pSettings The settings.
3581	*
3582	* @todo
3583	*
3584	* Ideas for C/C++:
3585	* - space after if, while, for, switch
3586	* - spaces in for (i=0;i<x;i++)
3587	* - complex conditional, bird style.
3588	* - remove unnecessary parentheses.
3589	* - sort defined RT_OS_*\|\| and RT_ARCH
3590	* - sizeof without parenthesis.
3591	* - defined without parenthesis.
3592	* - trailing spaces.
3593	* - parameter indentation.
3594	* - space after comma.
3595	* - while (x--); -> multi line + comment.
3596	* - else statement;
3597	* - space between function and left parenthesis.
3598	* - TODO, XXX, @todo cleanup.
3599	* - Space before/after '*'.
3600	* - ensure new line at end of file.
3601	* - Indentation of precompiler statements (#ifdef, #defines).
3602	* - space between functions.
3603	* - string.h -> iprt/string.h, stdarg.h -> iprt/stdarg.h, etc.
3604	*/
3605	bool rewrite_C_and_CPP(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
3606	{
3607
3608	RT_NOREF4(pState, pIn, pOut, pSettings);
3609	return false;
3610	}
3611

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

source: vbox/trunk/src/bldprogs/scmrw.cpp@ 96445

Download in other formats: