VirtualBox

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

Last change on this file since 69564 was 69507, checked in by vboxsync, 7 years ago

scm: assertion fix
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 92.1 KB
Line 
1/* $Id: scmrw.cpp 69507 2017-10-28 18:43:39Z vboxsync $ */
2/** @file
3 * IPRT Testcase / Tool - Source Code Massager.
4 */
5
6/*
7 * Copyright (C) 2010-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#include <iprt/assert.h>
23#include <iprt/ctype.h>
24#include <iprt/dir.h>
25#include <iprt/env.h>
26#include <iprt/file.h>
27#include <iprt/err.h>
28#include <iprt/getopt.h>
29#include <iprt/initterm.h>
30#include <iprt/mem.h>
31#include <iprt/message.h>
32#include <iprt/param.h>
33#include <iprt/path.h>
34#include <iprt/process.h>
35#include <iprt/stream.h>
36#include <iprt/string.h>
37
38#include "scm.h"
39
40
41/*********************************************************************************************************************************
42* Structures and Typedefs *
43*********************************************************************************************************************************/
44/** License types. */
45typedef enum SCMLICENSETYPE
46{
47 kScmLicenseType_Invalid = 0,
48 kScmLicenseType_OseGpl,
49 kScmLicenseType_OseDualGplCddl,
50 kScmLicenseType_OseCddl,
51 kScmLicenseType_VBoxLgpl,
52 kScmLicenseType_Mit,
53 kScmLicenseType_Confidential
54} SCMLICENSETYPE;
55
56/** A license. */
57typedef struct SCMLICENSETEXT
58{
59 /** The license type. */
60 SCMLICENSETYPE enmType;
61 /** The license option. */
62 SCMLICENSE enmOpt;
63 /** The license text. */
64 const char *psz;
65 /** The license text length. */
66 size_t cch;
67} SCMLICENSETEXT;
68/** Pointer to a license. */
69typedef SCMLICENSETEXT const *PCSCMLICENSETEXT;
70
71/**
72 * Copyright + license rewriter state.
73 */
74typedef struct SCMCOPYRIGHTINFO
75{
76 /** State. */
77 PSCMRWSTATE pState; /**< input */
78 /** The comment style (neede for C/C++). */
79 SCMCOMMENTSTYLE enmCommentStyle; /**< input */
80
81 /** Number of comments we've parsed. */
82 uint32_t cComments;
83
84 /** Copy of the contributed-by line if present. */
85 char *pszContributedBy;
86
87 /** @name Common info
88 * @{ */
89 uint32_t iLineComment;
90 uint32_t cLinesComment; /**< This excludes any external license lines. */
91 /** @} */
92
93 /** @name Copyright info
94 * @{ */
95 uint32_t iLineCopyright;
96 uint32_t uFirstYear;
97 uint32_t uLastYear;
98 bool fWellFormedCopyright;
99 bool fUpToDateCopyright;
100 /** @} */
101
102 /** @name License info
103 * @{ */
104 bool fOpenSource; /**< input */
105 PCSCMLICENSETEXT pExpectedLicense; /**< input */
106 PCSCMLICENSETEXT paLicenses; /**< input */
107 SCMLICENSE enmLicenceOpt; /**< input */
108 uint32_t iLineLicense;
109 uint32_t cLinesLicense;
110 PCSCMLICENSETEXT pCurrentLicense;
111 bool fIsCorrectLicense;
112 bool fWellFormedLicense;
113 bool fExternalLicense;
114 /** @} */
115
116 /** @name LGPL licence notice and disclaimer info
117 * @{ */
118 /** Wheter to check for LGPL license notices and disclaimers. */
119 bool fCheckforLgpl;
120 /** The approximate line we found the (first) LGPL licence notice on. */
121 uint32_t iLineLgplNotice;
122 /** The line number after the LGPL notice comment. */
123 uint32_t iLineAfterLgplComment;
124 /** The LGPL disclaimer line. */
125 uint32_t iLineLgplDisclaimer;
126 /** @} */
127
128} SCMCOPYRIGHTINFO;
129typedef SCMCOPYRIGHTINFO *PSCMCOPYRIGHTINFO;
130
131
132/*********************************************************************************************************************************
133* Global Variables *
134*********************************************************************************************************************************/
135/** --license-ose-gpl */
136static const char g_szVBoxOseGpl[] =
137 "This file is part of VirtualBox Open Source Edition (OSE), as\n"
138 "available from http://www.virtualbox.org. This file is free software;\n"
139 "you can redistribute it and/or modify it under the terms of the GNU\n"
140 "General Public License (GPL) as published by the Free Software\n"
141 "Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
142 "VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
143 "hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n";
144
145/** --license-ose-dual */
146static const char g_szVBoxOseDualGplCddl[] =
147 "This file is part of VirtualBox Open Source Edition (OSE), as\n"
148 "available from http://www.virtualbox.org. This file is free software;\n"
149 "you can redistribute it and/or modify it under the terms of the GNU\n"
150 "General Public License (GPL) as published by the Free Software\n"
151 "Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
152 "VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
153 "hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n"
154 "\n"
155 "The contents of this file may alternatively be used under the terms\n"
156 "of the Common Development and Distribution License Version 1.0\n"
157 "(CDDL) only, as it comes in the \"COPYING.CDDL\" file of the\n"
158 "VirtualBox OSE distribution, in which case the provisions of the\n"
159 "CDDL are applicable instead of those of the GPL.\n"
160 "\n"
161 "You may elect to license modified versions of this file under the\n"
162 "terms and conditions of either the GPL or the CDDL or both.\n";
163
164/** --license-ose-cddl */
165static const char g_szVBoxOseCddl[] =
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 Common\n"
169 "Development and Distribution License Version 1.0 (CDDL) only, as it\n"
170 "comes in the \"COPYING.CDDL\" file of the VirtualBox OSE distribution.\n"
171 "VirtualBox OSE is distributed in the hope that it will be useful, but\n"
172 "WITHOUT ANY WARRANTY of any kind.\n";
173
174/** --license-lgpl */
175static const char g_szVBoxLgpl[] =
176 "This file is part of a free software library; you can redistribute\n"
177 "it and/or modify it under the terms of the GNU Lesser General\n"
178 "Public License version 2.1 as published by the Free Software\n"
179 "Foundation and shipped in the \"COPYING\" file with this library.\n"
180 "The library is distributed in the hope that it will be useful,\n"
181 "but WITHOUT ANY WARRANTY of any kind.\n"
182 "\n"
183 "Oracle LGPL Disclaimer: For the avoidance of doubt, except that if\n"
184 "any license choice other than GPL or LGPL is available it will\n"
185 "apply instead, Oracle elects to use only the Lesser General Public\n"
186 "License version 2.1 (LGPLv2) at this time for any software where\n"
187 "a choice of LGPL license versions is made available with the\n"
188 "language indicating that LGPLv2 or any later version may be used,\n"
189 "or where a choice of which version of the LGPL is applied is\n"
190 "otherwise unspecified.\n";
191
192/** --license-mit
193 * @note This isn't detectable as VirtualBox or Oracle specific.
194 */
195static const char g_szMit[] =
196 "Permission is hereby granted, free of charge, to any person\n"
197 "obtaining a copy of this software and associated documentation\n"
198 "files (the \"Software\"), to deal in the Software without\n"
199 "restriction, including without limitation the rights to use,\n"
200 "copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
201 "copies of the Software, and to permit persons to whom the\n"
202 "Software is furnished to do so, subject to the following\n"
203 "conditions:\n"
204 "\n"
205 "The above copyright notice and this permission notice shall be\n"
206 "included in all copies or substantial portions of the Software.\n"
207 "\n"
208 "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n"
209 "EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n"
210 "OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n"
211 "NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n"
212 "HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n"
213 "WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
214 "FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
215 "OTHER DEALINGS IN THE SOFTWARE.\n";
216
217/** --license-mit, alternative wording \#1.
218 * @note This differes from g_szMit in "AUTHORS OR COPYRIGHT HOLDERS" is written
219 * "COPYRIGHT HOLDER(S) OR AUTHOR(S)". Its layout is wider, so it is a
220 * couple of lines shorter. */
221static const char g_szMitAlt1[] =
222 "Permission is hereby granted, free of charge, to any person obtaining a\n"
223 "copy of this software and associated documentation files (the \"Software\"),\n"
224 "to deal in the Software without restriction, including without limitation\n"
225 "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
226 "and/or sell copies of the Software, and to permit persons to whom the\n"
227 "Software is furnished to do so, subject to the following conditions:\n"
228 "\n"
229 "The above copyright notice and this permission notice shall be included in\n"
230 "all copies or substantial portions of the Software.\n"
231 "\n"
232 "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
233 "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
234 "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n"
235 "THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR\n"
236 "OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n"
237 "ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
238 "OTHER DEALINGS IN THE SOFTWARE.\n";
239
240/** --license-mit, alternative wording \#2.
241 * @note This differes from g_szMit in that "AUTHORS OR COPYRIGHT HOLDERS" is
242 * replaced with "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS".
243 * Its layout is wider, so it is a couple of lines shorter. */
244static const char g_szMitAlt2[] =
245 "Permission is hereby granted, free of charge, to any person obtaining a\n"
246 "copy of this software and associated documentation files (the \"Software\"),\n"
247 "to deal in the Software without restriction, including without limitation\n"
248 "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
249 "and/or sell copies of the Software, and to permit persons to whom the\n"
250 "Software is furnished to do so, subject to the following conditions:\n"
251 "\n"
252 "The above copyright notice and this permission notice shall be included in\n"
253 "all copies or substantial portions of the Software.\n"
254 "\n"
255 "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
256 "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
257 "FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
258 "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
259 "DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
260 "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
261 "USE OR OTHER DEALINGS IN THE SOFTWARE.\n";
262
263/** --license-mit, alternative wording \#3.
264 * @note This differes from g_szMitAlt2 in that the second and third sections
265 * have been switch. */
266static const char g_szMitAlt3[] =
267 "Permission is hereby granted, free of charge, to any person obtaining a\n"
268 "copy of this software and associated documentation files (the \"Software\"),\n"
269 "to deal in the Software without restriction, including without limitation\n"
270 "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
271 "and/or sell copies of the Software, and to permit persons to whom the\n"
272 "Software is furnished to do so, subject to the following conditions:\n"
273 "\n"
274 "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
275 "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
276 "FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
277 "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
278 "DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
279 "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
280 "USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
281 "\n"
282 "The above copyright notice and this permission notice shall be included in\n"
283 "all copies or substantial portions of the Software.\n";
284
285/** --license-(based-on)mit, alternative wording \#4.
286 * @note This differs from g_szMitAlt2 in injecting "(including the next
287 * paragraph)". */
288static const char g_szMitAlt4[] =
289 "Permission is hereby granted, free of charge, to any person obtaining a\n"
290 "copy of this software and associated documentation files (the \"Software\"),\n"
291 "to deal in the Software without restriction, including without limitation\n"
292 "the rights to use, copy, modify, merge, publish, distribute, sublicense,\n"
293 "and/or sell copies of the Software, and to permit persons to whom the\n"
294 "Software is furnished to do so, subject to the following conditions:\n"
295 "\n"
296 "The above copyright notice and this permission notice (including the next\n"
297 "paragraph) shall be included in all copies or substantial portions of the\n"
298 "Software.\n"
299 "\n"
300 "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
301 "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
302 "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n"
303 "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n"
304 "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
305 "FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n"
306 "DEALINGS IN THE SOFTWARE.\n";
307
308/** --license-(based-on)mit, alternative wording \#5.
309 * @note This differs from g_szMitAlt3 in using "sub license" instead of
310 * "sublicense" and adding an illogical "(including the next
311 * paragraph)" remark to the final paragraph. (vbox_ttm.c) */
312static const char g_szMitAlt5[] =
313 "Permission is hereby granted, free of charge, to any person obtaining a\n"
314 "copy of this software and associated documentation files (the\n"
315 "\"Software\"), to deal in the Software without restriction, including\n"
316 "without limitation the rights to use, copy, modify, merge, publish,\n"
317 "distribute, sub license, and/or sell copies of the Software, and to\n"
318 "permit persons to whom the Software is furnished to do so, subject to\n"
319 "the following conditions:\n"
320 "\n"
321 "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
322 "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
323 "FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL\n"
324 "THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,\n"
325 "DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n"
326 "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n"
327 "USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
328 "\n"
329 "The above copyright notice and this permission notice (including the\n"
330 "next paragraph) shall be included in all copies or substantial portions\n"
331 "of the Software.\n";
332
333/** Oracle confidential. */
334static const char g_szOracleConfidential[] =
335 "Oracle Corporation confidential\n"
336 "All rights reserved\n";
337
338/** Licenses to detect when --license-mit isn't used. */
339static const SCMLICENSETEXT g_aLicenses[] =
340{
341 { kScmLicenseType_OseGpl, kScmLicense_OseGpl, RT_STR_TUPLE(g_szVBoxOseGpl)},
342 { kScmLicenseType_OseDualGplCddl, kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
343 { kScmLicenseType_OseCddl, kScmLicense_OseCddl, RT_STR_TUPLE(g_szVBoxOseCddl) },
344 { kScmLicenseType_VBoxLgpl, kScmLicense_Lgpl, RT_STR_TUPLE(g_szVBoxLgpl)},
345 { kScmLicenseType_Confidential, kScmLicense_End, RT_STR_TUPLE(g_szOracleConfidential) },
346 { kScmLicenseType_Invalid, kScmLicense_End, NULL, 0 },
347};
348
349/** Licenses to detect when --license-mit or --license-based-on-mit are used. */
350static const SCMLICENSETEXT g_aLicensesWithMit[] =
351{
352 { kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMit) },
353 { kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt1) },
354 { kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt2) },
355 { kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt3) },
356 { kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt4) },
357 { kScmLicenseType_Mit, kScmLicense_Mit, RT_STR_TUPLE(g_szMitAlt5) },
358 { kScmLicenseType_OseGpl, kScmLicense_OseGpl, RT_STR_TUPLE(g_szVBoxOseGpl)},
359 { kScmLicenseType_OseDualGplCddl, kScmLicense_OseDualGplCddl, RT_STR_TUPLE(g_szVBoxOseDualGplCddl) },
360 { kScmLicenseType_VBoxLgpl, kScmLicense_Lgpl, RT_STR_TUPLE(g_szVBoxLgpl)},
361 { kScmLicenseType_Confidential, kScmLicense_End, RT_STR_TUPLE(g_szOracleConfidential) },
362 { kScmLicenseType_Invalid, kScmLicense_End, NULL, 0 },
363};
364
365/** Copyright holder. */
366static const char g_szCopyrightHolder[] = "Oracle Corporation";
367
368/** LGPL disclaimer. */
369static const char g_szLgplDisclaimer[] =
370 "Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice\n"
371 "other than GPL or LGPL is available it will apply instead, Oracle elects to use only\n"
372 "the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where\n"
373 "a choice of LGPL license versions is made available with the language indicating\n"
374 "that LGPLv2 or any later version may be used, or where a choice of which version\n"
375 "of the LGPL is applied is otherwise unspecified.\n";
376
377/** Copyright+license comment start for each SCMCOMMENTSTYLE. */
378static RTSTRTUPLE const g_aCopyrightCommentStart[] =
379{
380 { RT_STR_TUPLE("<invalid> ") },
381 { RT_STR_TUPLE("/*") },
382 { RT_STR_TUPLE("#") },
383 { RT_STR_TUPLE("\"\"\"") },
384 { RT_STR_TUPLE(";") },
385 { RT_STR_TUPLE("REM") },
386 { RT_STR_TUPLE("rem") },
387 { RT_STR_TUPLE("Rem") },
388 { RT_STR_TUPLE("--") },
389 { RT_STR_TUPLE("'") },
390 { RT_STR_TUPLE("<end>") },
391};
392
393/** Copyright+license line prefix for each SCMCOMMENTSTYLE. */
394static RTSTRTUPLE const g_aCopyrightCommentPrefix[] =
395{
396 { RT_STR_TUPLE("<invalid> ") },
397 { RT_STR_TUPLE(" * ") },
398 { RT_STR_TUPLE("# ") },
399 { RT_STR_TUPLE("") },
400 { RT_STR_TUPLE("; ") },
401 { RT_STR_TUPLE("REM ") },
402 { RT_STR_TUPLE("rem ") },
403 { RT_STR_TUPLE("Rem ") },
404 { RT_STR_TUPLE("-- ") },
405 { RT_STR_TUPLE("' ") },
406 { RT_STR_TUPLE("<end>") },
407};
408
409/** Copyright+license empty line for each SCMCOMMENTSTYLE. */
410static RTSTRTUPLE const g_aCopyrightCommentEmpty[] =
411{
412 { RT_STR_TUPLE("<invalid>") },
413 { RT_STR_TUPLE(" *") },
414 { RT_STR_TUPLE("#") },
415 { RT_STR_TUPLE("") },
416 { RT_STR_TUPLE(";") },
417 { RT_STR_TUPLE("REM") },
418 { RT_STR_TUPLE("rem") },
419 { RT_STR_TUPLE("Rem") },
420 { RT_STR_TUPLE("--") },
421 { RT_STR_TUPLE("'") },
422 { RT_STR_TUPLE("<end>") },
423};
424
425/** Copyright+license end of comment for each SCMCOMMENTSTYLE. */
426static RTSTRTUPLE const g_aCopyrightCommentEnd[] =
427{
428 { RT_STR_TUPLE("<invalid> ") },
429 { RT_STR_TUPLE(" */") },
430 { RT_STR_TUPLE("#") },
431 { RT_STR_TUPLE("\"\"\"") },
432 { RT_STR_TUPLE(";") },
433 { RT_STR_TUPLE("REM") },
434 { RT_STR_TUPLE("rem") },
435 { RT_STR_TUPLE("Rem") },
436 { RT_STR_TUPLE("--") },
437 { RT_STR_TUPLE("'") },
438 { RT_STR_TUPLE("<end>") },
439};
440
441
442/**
443 * Figures out the predominant casing of the "REM" keyword in a batch file.
444 *
445 * @returns Predominant comment style.
446 * @param pIn The file to scan. Will be rewound.
447 */
448static SCMCOMMENTSTYLE determinBatchFileCommentStyle(PSCMSTREAM pIn)
449{
450 /*
451 * Figure out whether it's using upper or lower case REM comments before
452 * doing the work.
453 */
454 uint32_t cUpper = 0;
455 uint32_t cLower = 0;
456 uint32_t cCamel = 0;
457 SCMEOL enmEol;
458 size_t cchLine;
459 const char *pchLine;
460 while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
461 {
462 while ( cchLine > 2
463 && RT_C_IS_SPACE(*pchLine))
464 {
465 pchLine++;
466 cchLine--;
467 }
468 if ( ( cchLine > 3
469 && RT_C_IS_SPACE(pchLine[2]))
470 || cchLine == 3)
471 {
472 if ( pchLine[0] == 'R'
473 && pchLine[1] == 'E'
474 && pchLine[2] == 'M')
475 cUpper++;
476 else if ( pchLine[0] == 'r'
477 && pchLine[1] == 'e'
478 && pchLine[2] == 'm')
479 cLower++;
480 else if ( pchLine[0] == 'R'
481 && pchLine[1] == 'e'
482 && pchLine[2] == 'm')
483 cCamel++;
484 }
485 }
486
487 ScmStreamRewindForReading(pIn);
488
489 if (cLower >= cUpper && cLower >= cCamel)
490 return kScmCommentStyle_Rem_Lower;
491 if (cCamel >= cLower && cCamel >= cUpper)
492 return kScmCommentStyle_Rem_Camel;
493 return kScmCommentStyle_Rem_Upper;
494}
495
496
497/**
498 * Worker for isBlankLine.
499 *
500 * @returns true if blank, false if not.
501 * @param pchLine Pointer to the start of the line.
502 * @param cchLine The (encoded) length of the line, excluding EOL char.
503 */
504static bool isBlankLineSlow(const char *pchLine, size_t cchLine)
505{
506 /*
507 * From the end, more likely to hit a non-blank char there.
508 */
509 while (cchLine-- > 0)
510 if (!RT_C_IS_BLANK(pchLine[cchLine]))
511 return false;
512 return true;
513}
514
515/**
516 * Helper for checking whether a line is blank.
517 *
518 * @returns true if blank, false if not.
519 * @param pchLine Pointer to the start of the line.
520 * @param cchLine The (encoded) length of the line, excluding EOL char.
521 */
522DECLINLINE(bool) isBlankLine(const char *pchLine, size_t cchLine)
523{
524 if (cchLine == 0)
525 return true;
526 /*
527 * We're more likely to fine a non-space char at the end of the line than
528 * at the start, due to source code indentation.
529 */
530 if (pchLine[cchLine - 1])
531 return false;
532
533 /*
534 * Don't bother inlining loop code.
535 */
536 return isBlankLineSlow(pchLine, cchLine);
537}
538
539
540/**
541 * Strip trailing blanks (space & tab).
542 *
543 * @returns True if modified, false if not.
544 * @param pIn The input stream.
545 * @param pOut The output stream.
546 * @param pSettings The settings.
547 */
548bool rewrite_StripTrailingBlanks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
549{
550 if (!pSettings->fStripTrailingBlanks)
551 return false;
552
553 bool fModified = false;
554 SCMEOL enmEol;
555 size_t cchLine;
556 const char *pchLine;
557 while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
558 {
559 int rc;
560 if ( cchLine == 0
561 || !RT_C_IS_BLANK(pchLine[cchLine - 1]) )
562 rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
563 else
564 {
565 cchLine--;
566 while (cchLine > 0 && RT_C_IS_BLANK(pchLine[cchLine - 1]))
567 cchLine--;
568 rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
569 fModified = true;
570 }
571 if (RT_FAILURE(rc))
572 return false;
573 }
574 if (fModified)
575 ScmVerbose(pState, 2, " * Stripped trailing blanks\n");
576 return fModified;
577}
578
579/**
580 * Expand tabs.
581 *
582 * @returns True if modified, false if not.
583 * @param pIn The input stream.
584 * @param pOut The output stream.
585 * @param pSettings The settings.
586 */
587bool rewrite_ExpandTabs(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
588{
589 if (!pSettings->fConvertTabs)
590 return false;
591
592 size_t const cchTab = pSettings->cchTab;
593 bool fModified = false;
594 SCMEOL enmEol;
595 size_t cchLine;
596 const char *pchLine;
597 while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
598 {
599 int rc;
600 const char *pchTab = (const char *)memchr(pchLine, '\t', cchLine);
601 if (!pchTab)
602 rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
603 else
604 {
605 size_t offTab = 0;
606 const char *pchChunk = pchLine;
607 for (;;)
608 {
609 size_t cchChunk = pchTab - pchChunk;
610 offTab += cchChunk;
611 ScmStreamWrite(pOut, pchChunk, cchChunk);
612
613 size_t cchToTab = cchTab - offTab % cchTab;
614 ScmStreamWrite(pOut, g_szTabSpaces, cchToTab);
615 offTab += cchToTab;
616
617 pchChunk = pchTab + 1;
618 size_t cchLeft = cchLine - (pchChunk - pchLine);
619 pchTab = (const char *)memchr(pchChunk, '\t', cchLeft);
620 if (!pchTab)
621 {
622 rc = ScmStreamPutLine(pOut, pchChunk, cchLeft, enmEol);
623 break;
624 }
625 }
626
627 fModified = true;
628 }
629 if (RT_FAILURE(rc))
630 return false;
631 }
632 if (fModified)
633 ScmVerbose(pState, 2, " * Expanded tabs\n");
634 return fModified;
635}
636
637/**
638 * Worker for rewrite_ForceNativeEol, rewrite_ForceLF and rewrite_ForceCRLF.
639 *
640 * @returns true if modifications were made, false if not.
641 * @param pIn The input stream.
642 * @param pOut The output stream.
643 * @param pSettings The settings.
644 * @param enmDesiredEol The desired end of line indicator type.
645 * @param pszDesiredSvnEol The desired svn:eol-style.
646 */
647static bool rewrite_ForceEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
648 SCMEOL enmDesiredEol, const char *pszDesiredSvnEol)
649{
650 if (!pSettings->fConvertEol)
651 return false;
652
653 bool fModified = false;
654 SCMEOL enmEol;
655 size_t cchLine;
656 const char *pchLine;
657 while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
658 {
659 if ( enmEol != enmDesiredEol
660 && enmEol != SCMEOL_NONE)
661 {
662 fModified = true;
663 enmEol = enmDesiredEol;
664 }
665 int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
666 if (RT_FAILURE(rc))
667 return false;
668 }
669 if (fModified)
670 ScmVerbose(pState, 2, " * Converted EOL markers\n");
671
672 /* Check svn:eol-style if appropriate */
673 if ( pSettings->fSetSvnEol
674 && ScmSvnIsInWorkingCopy(pState))
675 {
676 char *pszEol;
677 int rc = ScmSvnQueryProperty(pState, "svn:eol-style", &pszEol);
678 if ( (RT_SUCCESS(rc) && strcmp(pszEol, pszDesiredSvnEol))
679 || rc == VERR_NOT_FOUND)
680 {
681 if (rc == VERR_NOT_FOUND)
682 ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (missing)\n", pszDesiredSvnEol);
683 else
684 ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (was: %s)\n", pszDesiredSvnEol, pszEol);
685 int rc2 = ScmSvnSetProperty(pState, "svn:eol-style", pszDesiredSvnEol);
686 if (RT_FAILURE(rc2))
687 ScmError(pState, rc2, "ScmSvnSetProperty: %Rrc\n", rc2);
688 }
689 if (RT_SUCCESS(rc))
690 RTStrFree(pszEol);
691 }
692
693 /** @todo also check the subversion svn:eol-style state! */
694 return fModified;
695}
696
697/**
698 * Force native end of line indicator.
699 *
700 * @returns true if modifications were made, false if not.
701 * @param pIn The input stream.
702 * @param pOut The output stream.
703 * @param pSettings The settings.
704 */
705bool rewrite_ForceNativeEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
706{
707#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
708 return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "native");
709#else
710 return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF, "native");
711#endif
712}
713
714/**
715 * Force the stream to use LF as the end of line indicator.
716 *
717 * @returns true if modifications were made, false if not.
718 * @param pIn The input stream.
719 * @param pOut The output stream.
720 * @param pSettings The settings.
721 */
722bool rewrite_ForceLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
723{
724 return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF, "LF");
725}
726
727/**
728 * Force the stream to use CRLF as the end of line indicator.
729 *
730 * @returns true if modifications were made, false if not.
731 * @param pIn The input stream.
732 * @param pOut The output stream.
733 * @param pSettings The settings.
734 */
735bool rewrite_ForceCRLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
736{
737 return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "CRLF");
738}
739
740/**
741 * Strip trailing blank lines and/or make sure there is exactly one blank line
742 * at the end of the file.
743 *
744 * @returns true if modifications were made, false if not.
745 * @param pIn The input stream.
746 * @param pOut The output stream.
747 * @param pSettings The settings.
748 *
749 * @remarks ASSUMES trailing white space has been removed already.
750 */
751bool rewrite_AdjustTrailingLines(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
752{
753 if ( !pSettings->fStripTrailingLines
754 && !pSettings->fForceTrailingLine
755 && !pSettings->fForceFinalEol)
756 return false;
757
758 size_t const cLines = ScmStreamCountLines(pIn);
759
760 /* Empty files remains empty. */
761 if (cLines <= 1)
762 return false;
763
764 /* Figure out if we need to adjust the number of lines or not. */
765 size_t cLinesNew = cLines;
766
767 if ( pSettings->fStripTrailingLines
768 && ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
769 {
770 while ( cLinesNew > 1
771 && ScmStreamIsWhiteLine(pIn, cLinesNew - 2))
772 cLinesNew--;
773 }
774
775 if ( pSettings->fForceTrailingLine
776 && !ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
777 cLinesNew++;
778
779 bool fFixMissingEol = pSettings->fForceFinalEol
780 && ScmStreamGetEolByLine(pIn, cLinesNew - 1) == SCMEOL_NONE;
781
782 if ( !fFixMissingEol
783 && cLines == cLinesNew)
784 return false;
785
786 /* Copy the number of lines we've arrived at. */
787 ScmStreamRewindForReading(pIn);
788
789 size_t cCopied = RT_MIN(cLinesNew, cLines);
790 ScmStreamCopyLines(pOut, pIn, cCopied);
791
792 if (cCopied != cLinesNew)
793 {
794 while (cCopied++ < cLinesNew)
795 ScmStreamPutLine(pOut, "", 0, ScmStreamGetEol(pIn));
796 }
797 /* Fix missing EOL if required. */
798 else if (fFixMissingEol)
799 {
800 if (ScmStreamGetEol(pIn) == SCMEOL_LF)
801 ScmStreamWrite(pOut, "\n", 1);
802 else
803 ScmStreamWrite(pOut, "\r\n", 2);
804 }
805
806 ScmVerbose(pState, 2, " * Adjusted trailing blank lines\n");
807 return true;
808}
809
810/**
811 * Make sure there is no svn:executable property on the current file.
812 *
813 * @returns false - the state carries these kinds of changes.
814 * @param pState The rewriter state.
815 * @param pIn The input stream.
816 * @param pOut The output stream.
817 * @param pSettings The settings.
818 */
819bool rewrite_SvnNoExecutable(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
820{
821 RT_NOREF2(pIn, pOut);
822 if ( !pSettings->fSetSvnExecutable
823 || !ScmSvnIsInWorkingCopy(pState))
824 return false;
825
826 int rc = ScmSvnQueryProperty(pState, "svn:executable", NULL);
827 if (RT_SUCCESS(rc))
828 {
829 ScmVerbose(pState, 2, " * removing svn:executable\n");
830 rc = ScmSvnDelProperty(pState, "svn:executable");
831 if (RT_FAILURE(rc))
832 ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
833 }
834 return false;
835}
836
837/**
838 * Make sure there is no svn:keywords property on the current file.
839 *
840 * @returns false - the state carries these kinds of changes.
841 * @param pState The rewriter state.
842 * @param pIn The input stream.
843 * @param pOut The output stream.
844 * @param pSettings The settings.
845 */
846bool rewrite_SvnNoKeywords(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
847{
848 RT_NOREF2(pIn, pOut);
849 if ( !pSettings->fSetSvnExecutable
850 || !ScmSvnIsInWorkingCopy(pState))
851 return false;
852
853 int rc = ScmSvnQueryProperty(pState, "svn:keywords", NULL);
854 if (RT_SUCCESS(rc))
855 {
856 ScmVerbose(pState, 2, " * removing svn:keywords\n");
857 rc = ScmSvnDelProperty(pState, "svn:keywords");
858 if (RT_FAILURE(rc))
859 ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
860 }
861 return false;
862}
863
864/**
865 * Make sure there is no svn:eol-style property on the current file.
866 *
867 * @returns false - the state carries these kinds of changes.
868 * @param pState The rewriter state.
869 * @param pIn The input stream.
870 * @param pOut The output stream.
871 * @param pSettings The settings.
872 */
873bool rewrite_SvnNoEolStyle(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
874{
875 RT_NOREF2(pIn, pOut);
876 if ( !pSettings->fSetSvnExecutable
877 || !ScmSvnIsInWorkingCopy(pState))
878 return false;
879
880 int rc = ScmSvnQueryProperty(pState, "svn:eol-style", NULL);
881 if (RT_SUCCESS(rc))
882 {
883 ScmVerbose(pState, 2, " * removing svn:eol-style\n");
884 rc = ScmSvnDelProperty(pState, "svn:eol-style");
885 if (RT_FAILURE(rc))
886 ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
887 }
888 return false;
889}
890
891/**
892 * Makes sure the svn properties are appropriate for a binary.
893 *
894 * @returns false - the state carries these kinds of changes.
895 * @param pState The rewriter state.
896 * @param pIn The input stream.
897 * @param pOut The output stream.
898 * @param pSettings The settings.
899 */
900bool rewrite_SvnBinary(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
901{
902 RT_NOREF2(pIn, pOut);
903 if ( !pSettings->fSetSvnExecutable
904 || !ScmSvnIsInWorkingCopy(pState))
905 return false;
906
907 /* remove svn:eol-style and svn:keywords */
908 static const char * const s_apszRemove[] = { "svn:eol-style", "svn:keywords" };
909 for (uint32_t i = 0; i < RT_ELEMENTS(s_apszRemove); i++)
910 {
911 char *pszValue;
912 int rc = ScmSvnQueryProperty(pState, s_apszRemove[i], &pszValue);
913 if (RT_SUCCESS(rc))
914 {
915 ScmVerbose(pState, 2, " * removing %s=%s\n", s_apszRemove[i], pszValue);
916 RTStrFree(pszValue);
917 rc = ScmSvnDelProperty(pState, s_apszRemove[i]);
918 if (RT_FAILURE(rc))
919 ScmError(pState, rc, "ScmSvnSetProperty(,%s): %Rrc\n", s_apszRemove[i], rc);
920 }
921 else if (rc != VERR_NOT_FOUND)
922 ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
923 }
924
925 /* Make sure there is a svn:mime-type set. */
926 int rc = ScmSvnQueryProperty(pState, "svn:mime-type", NULL);
927 if (rc == VERR_NOT_FOUND)
928 {
929 ScmVerbose(pState, 2, " * settings svn:mime-type\n");
930 rc = ScmSvnSetProperty(pState, "svn:mime-type", "application/octet-stream");
931 if (RT_FAILURE(rc))
932 ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
933 }
934 else if (RT_FAILURE(rc))
935 ScmError(pState, rc, "ScmSvnQueryProperty: %Rrc\n", rc);
936
937 return false;
938}
939
940/**
941 * Make sure the Id and Revision keywords are expanded.
942 *
943 * @returns false - the state carries these kinds of changes.
944 * @param pState The rewriter state.
945 * @param pIn The input stream.
946 * @param pOut The output stream.
947 * @param pSettings The settings.
948 */
949bool rewrite_SvnKeywords(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
950{
951 RT_NOREF2(pIn, pOut);
952 if ( !pSettings->fSetSvnKeywords
953 || !ScmSvnIsInWorkingCopy(pState))
954 return false;
955
956 char *pszKeywords;
957 int rc = ScmSvnQueryProperty(pState, "svn:keywords", &pszKeywords);
958 if ( RT_SUCCESS(rc)
959 && ( !strstr(pszKeywords, "Id") /** @todo need some function for finding a word in a string. */
960 || !strstr(pszKeywords, "Revision")) )
961 {
962 if (!strstr(pszKeywords, "Id") && !strstr(pszKeywords, "Revision"))
963 rc = RTStrAAppend(&pszKeywords, " Id Revision");
964 else if (!strstr(pszKeywords, "Id"))
965 rc = RTStrAAppend(&pszKeywords, " Id");
966 else
967 rc = RTStrAAppend(&pszKeywords, " Revision");
968 if (RT_SUCCESS(rc))
969 {
970 ScmVerbose(pState, 2, " * changing svn:keywords to '%s'\n", pszKeywords);
971 rc = ScmSvnSetProperty(pState, "svn:keywords", pszKeywords);
972 if (RT_FAILURE(rc))
973 ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
974 }
975 else
976 ScmError(pState, rc, "RTStrAppend: %Rrc\n", rc);
977 RTStrFree(pszKeywords);
978 }
979 else if (rc == VERR_NOT_FOUND)
980 {
981 ScmVerbose(pState, 2, " * setting svn:keywords to 'Id Revision'\n");
982 rc = ScmSvnSetProperty(pState, "svn:keywords", "Id Revision");
983 if (RT_FAILURE(rc))
984 ScmError(pState, rc, "ScmSvnSetProperty: %Rrc\n", rc);
985 }
986 else if (RT_SUCCESS(rc))
987 RTStrFree(pszKeywords);
988
989 return false;
990}
991
992/**
993 * Compares two strings word-by-word, ignoring spaces, punctuation and case.
994 *
995 * Assumes ASCII strings.
996 *
997 * @returns true if they match, false if not.
998 * @param psz1 The first string. This is typically the known one.
999 * @param psz2 The second string. This is typically the unknown one,
1000 * which is why we return a next pointer for this one.
1001 * @param ppsz2Next Where to return the next part of the 2nd string. If
1002 * this is NULL, the whole string must match.
1003 */
1004static bool IsEqualWordByWordIgnoreCase(const char *psz1, const char *psz2, const char **ppsz2Next)
1005{
1006 for (;;)
1007 {
1008 /* Try compare raw strings first. */
1009 char ch1 = *psz1;
1010 char ch2 = *psz2;
1011 if ( ch1 == ch2
1012 || RT_C_TO_LOWER(ch1) == RT_C_TO_LOWER(ch2))
1013 {
1014 if (ch1)
1015 {
1016 psz1++;
1017 psz2++;
1018 }
1019 else
1020 {
1021 if (ppsz2Next)
1022 *ppsz2Next = psz2;
1023 return true;
1024 }
1025 }
1026 else
1027 {
1028 /* Try skip spaces an punctuation. */
1029 while ( RT_C_IS_SPACE(ch1)
1030 || RT_C_IS_PUNCT(ch1))
1031 ch1 = *++psz1;
1032
1033 if (ch1 == '\0' && ppsz2Next)
1034 {
1035 *ppsz2Next = psz2;
1036 return true;
1037 }
1038
1039 while ( RT_C_IS_SPACE(ch2)
1040 || RT_C_IS_PUNCT(ch2))
1041 ch2 = *++psz2;
1042
1043 if ( ch1 != ch2
1044 && RT_C_TO_LOWER(ch1) != RT_C_TO_LOWER(ch2))
1045 {
1046 if (ppsz2Next)
1047 *ppsz2Next = psz2;
1048 return false;
1049 }
1050 }
1051 }
1052}
1053
1054/**
1055 * Looks for @a pszFragment anywhere in @a pszText, ignoring spaces, punctuation
1056 * and case.
1057 *
1058 * @returns true if found, false if not.
1059 * @param pszText The haystack to search in.
1060 * @param cchText The length @a pszText.
1061 * @param pszFragment The needle to search for.
1062 * @param ppszStart Where to return the address in @a pszText where
1063 * the fragment was found. Optional.
1064 * @param ppszNext Where to return the pointer to the first char in
1065 * @a pszText after the fragment. Optional.
1066 *
1067 * @remarks First character of @a pszFragment must be an 7-bit ASCII character!
1068 * This character must not be space or punctuation.
1069 */
1070static bool scmContainsWordByWordIgnoreCase(const char *pszText, size_t cchText, const char *pszFragment,
1071 const char **ppszStart, const char **ppszNext)
1072{
1073 Assert(!((unsigned)*pszFragment & 0x80));
1074 Assert(pszText[cchText] == '\0');
1075 Assert(!RT_C_IS_BLANK(*pszFragment));
1076 Assert(!RT_C_IS_PUNCT(*pszFragment));
1077
1078 char chLower = RT_C_TO_LOWER(*pszFragment);
1079 char chUpper = RT_C_TO_UPPER(*pszFragment);
1080 for (;;)
1081 {
1082 const char *pszHit = (const char *)memchr(pszText, chLower, cchText);
1083 const char *pszHit2 = (const char *)memchr(pszText, chUpper, cchText);
1084 if (!pszHit && !pszHit2)
1085 {
1086 if (ppszStart)
1087 *ppszStart = NULL;
1088 if (ppszNext)
1089 *ppszNext = NULL;
1090 return false;
1091 }
1092
1093 if ( pszHit == NULL
1094 || ( pszHit2 != NULL
1095 && ((uintptr_t)pszHit2 < (uintptr_t)pszHit)) )
1096 pszHit = pszHit2;
1097
1098 const char *pszNext;
1099 if (IsEqualWordByWordIgnoreCase(pszFragment, pszHit, &pszNext))
1100 {
1101 if (ppszStart)
1102 *ppszStart = pszHit;
1103 if (ppszNext)
1104 *ppszNext = pszNext;
1105 return true;
1106 }
1107
1108 cchText -= pszHit - pszText + 1;
1109 pszText = pszHit + 1;
1110 }
1111}
1112
1113
1114/**
1115 * Counts the number of lines in the given substring.
1116 *
1117 * @returns The number of lines.
1118 * @param psz The start of the substring.
1119 * @param cch The length of the substring.
1120 */
1121static uint32_t CountLinesInSubstring(const char *psz, size_t cch)
1122{
1123 uint32_t cLines = 0;
1124 for (;;)
1125 {
1126 const char *pszEol = (const char *)memchr(psz, '\n', cch);
1127 if (pszEol)
1128 cLines++;
1129 else
1130 return cLines + (*psz != '\0');
1131 cch -= pszEol + 1 - psz;
1132 if (!cch)
1133 return cLines;
1134 psz = pszEol + 1;
1135 }
1136}
1137
1138
1139/**
1140 * Comment parser callback for locating copyright and license.
1141 */
1142static DECLCALLBACK(int)
1143rewrite_Copyright_CommentCallback(PCSCMCOMMENTINFO pInfo, const char *pszBody, size_t cchBody, void *pvUser)
1144{
1145 PSCMCOPYRIGHTINFO pState = (PSCMCOPYRIGHTINFO)pvUser;
1146 Assert(strlen(pszBody) == cchBody);
1147 //RTPrintf("--- comment at %u, type %u ---\n%s\n--- end ---\n", pInfo->iLineStart, pInfo->enmType, pszBody);
1148 ScmVerbose(pState->pState, 5,
1149 "--- comment at %u col %u, %u lines, type %u, %u lines before body, %u lines after body\n",
1150 pInfo->iLineStart, pInfo->offStart, pInfo->iLineEnd - pInfo->iLineStart + 1, pInfo->enmType,
1151 pInfo->cBlankLinesBefore, pInfo->cBlankLinesAfter);
1152
1153 pState->cComments++;
1154
1155 uint32_t iLine = pInfo->iLineStart + pInfo->cBlankLinesBefore;
1156
1157 /*
1158 * Look for a 'contributed by' or 'includes contributions from' line, these
1159 * comes first when present.
1160 */
1161 const char *pchContributedBy = NULL;
1162 size_t cchContributedBy = 0;
1163 size_t cBlankLinesAfterContributedBy = 0;
1164 if ( pState->pszContributedBy == NULL
1165 && ( pState->iLineCopyright == UINT32_MAX
1166 || pState->iLineLicense == UINT32_MAX)
1167 && ( ( cchBody > sizeof("Contributed by")
1168 && RTStrNICmp(pszBody, RT_STR_TUPLE("contributed by")) == 0)
1169 || ( cchBody > sizeof("Includes contributions from")
1170 && RTStrNICmp(pszBody, RT_STR_TUPLE("Includes contributions from")) == 0) ) )
1171 {
1172 const char *pszNextLine = (const char *)memchr(pszBody, '\n', cchBody);
1173 while (pszNextLine && pszNextLine[1] != '\n')
1174 pszNextLine = (const char *)memchr(pszNextLine + 1, '\n', cchBody);
1175 if (pszNextLine)
1176 {
1177 pchContributedBy = pszBody;
1178 cchContributedBy = pszNextLine - pszBody;
1179
1180 /* Skip the copyright line and any blank lines following it. */
1181 cchBody -= cchContributedBy + 1;
1182 pszBody = pszNextLine + 1;
1183 iLine += 1;
1184 while (*pszBody == '\n')
1185 {
1186 pszBody++;
1187 cchBody--;
1188 iLine++;
1189 cBlankLinesAfterContributedBy++;
1190 }
1191 }
1192 }
1193
1194 /*
1195 * Look for the copyright line.
1196 */
1197 bool fFoundCopyright = false;
1198 uint32_t cBlankLinesAfterCopyright = 0;
1199 if ( pState->iLineCopyright == UINT32_MAX
1200 && cchBody > sizeof("Copyright") + sizeof(g_szCopyrightHolder)
1201 && RTStrNICmp(pszBody, RT_STR_TUPLE("copyright")) == 0)
1202 {
1203 const char *pszNextLine = (const char *)memchr(pszBody, '\n', cchBody);
1204
1205 /* Oracle copyright? */
1206 const char *pszEnd = pszNextLine ? pszNextLine : &pszBody[cchBody];
1207 while (RT_C_IS_SPACE(pszEnd[-1]))
1208 pszEnd--;
1209 if ( (uintptr_t)(pszEnd - pszBody) > sizeof(g_szCopyrightHolder)
1210 && (*(unsigned char *)(pszEnd - sizeof(g_szCopyrightHolder) + 1) & 0x80) == 0 /* to avoid annoying assertion */
1211 && RTStrNICmp(pszEnd - sizeof(g_szCopyrightHolder) + 1, RT_STR_TUPLE(g_szCopyrightHolder)) == 0)
1212 {
1213 /* Parse out the year(s). */
1214 const char *psz = pszBody + sizeof("copyright");
1215 while ((uintptr_t)psz < (uintptr_t)pszEnd && !RT_C_IS_DIGIT(*psz))
1216 psz++;
1217 if (RT_C_IS_DIGIT(*psz))
1218 {
1219 char *pszNext;
1220 int rc = RTStrToUInt32Ex(psz, &pszNext, 10, &pState->uFirstYear);
1221 if ( RT_SUCCESS(rc)
1222 && rc != VWRN_NUMBER_TOO_BIG
1223 && rc != VWRN_NEGATIVE_UNSIGNED)
1224 {
1225 if ( pState->uFirstYear < 1975
1226 || pState->uFirstYear > 3000)
1227 {
1228 ScmError(pState->pState, VERR_OUT_OF_RANGE, "Copyright year is out of range: %u ('%.*s')\n",
1229 pState->uFirstYear, pszEnd - pszBody, pszBody);
1230 pState->uFirstYear = UINT32_MAX;
1231 }
1232
1233 while (RT_C_IS_SPACE(*pszNext))
1234 pszNext++;
1235 if (*pszNext == '-')
1236 {
1237 do
1238 pszNext++;
1239 while (RT_C_IS_SPACE(*pszNext));
1240 rc = RTStrToUInt32Ex(pszNext, &pszNext, 10, &pState->uLastYear);
1241 if ( RT_SUCCESS(rc)
1242 && rc != VWRN_NUMBER_TOO_BIG
1243 && rc != VWRN_NEGATIVE_UNSIGNED)
1244 {
1245 if ( pState->uLastYear < 1975
1246 || pState->uLastYear > 3000)
1247 {
1248 ScmError(pState->pState, VERR_OUT_OF_RANGE, "Second copyright year is out of range: %u ('%.*s')\n",
1249 pState->uLastYear, pszEnd - pszBody, pszBody);
1250 pState->uLastYear = UINT32_MAX;
1251 }
1252 else if (pState->uFirstYear > pState->uLastYear)
1253 {
1254 RTMsgWarning("Copyright years switched(?): '%.*s'\n", pszEnd - pszBody, pszBody);
1255 uint32_t iTmp = pState->uLastYear;
1256 pState->uLastYear = pState->uFirstYear;
1257 pState->uFirstYear = iTmp;
1258 }
1259 }
1260 else
1261 {
1262 pState->uLastYear = UINT32_MAX;
1263 ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
1264 "Failed to parse second copyright year: '%.*s'\n", pszEnd - pszBody, pszBody);
1265 }
1266 }
1267 else if (*pszNext != g_szCopyrightHolder[0])
1268 ScmError(pState->pState, VERR_PARSE_ERROR,
1269 "Failed to parse copyright: '%.*s'\n", pszEnd - pszBody, pszBody);
1270 else
1271 pState->uLastYear = pState->uFirstYear;
1272 }
1273 else
1274 {
1275 pState->uFirstYear = UINT32_MAX;
1276 ScmError(pState->pState, RT_SUCCESS(rc) ? -rc : rc,
1277 "Failed to parse copyright year: '%.*s'\n", pszEnd - pszBody, pszBody);
1278 }
1279 }
1280
1281 /* The copyright comment must come before the license. */
1282 if (pState->iLineLicense != UINT32_MAX)
1283 ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright (line %u) must come before the license (line %u)!\n",
1284 iLine, pState->iLineLicense);
1285
1286 /* In C/C++ code, this must be a multiline comment. While in python it
1287 must be a */
1288 if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
1289 ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a multiline comment (no doxygen stuff)\n");
1290 else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
1291 ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright must appear in a doc-string\n");
1292
1293 /* The copyright must be followed by the license. */
1294 if (!pszNextLine)
1295 ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
1296
1297 /* Quit if we've flagged a failure. */
1298 if (RT_FAILURE(pState->pState->rc))
1299 return VERR_CALLBACK_RETURN;
1300
1301 /* Check if it's well formed and up to date. */
1302 char szWellFormed[256];
1303 size_t cchWellFormed;
1304 if (pState->uFirstYear == pState->uLastYear)
1305 cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u %s",
1306 pState->uFirstYear, g_szCopyrightHolder);
1307 else
1308 cchWellFormed = RTStrPrintf(szWellFormed, sizeof(szWellFormed), "Copyright (C) %u-%u %s",
1309 pState->uFirstYear, pState->uLastYear, g_szCopyrightHolder);
1310 pState->fUpToDateCopyright = pState->uLastYear == g_uYear;
1311 pState->iLineCopyright = iLine;
1312 pState->fWellFormedCopyright = cchWellFormed == (uintptr_t)(pszEnd - pszBody)
1313 && memcmp(pszBody, szWellFormed, cchWellFormed) == 0;
1314 if (!pState->fWellFormedCopyright)
1315 ScmVerbose(pState->pState, 1, "* copyright isn't well formed\n");
1316
1317 /* If there wasn't exactly one blank line before the comment, trigger a rewrite. */
1318 if (pInfo->cBlankLinesBefore != 1)
1319 {
1320 ScmVerbose(pState->pState, 1, "* copyright comment is preceeded by %u blank lines instead of 1\n",
1321 pInfo->cBlankLinesBefore);
1322 pState->fWellFormedCopyright = false;
1323 }
1324
1325 /* If the comment doesn't start in column 1, trigger rewrite. */
1326 if (pInfo->offStart != 0)
1327 {
1328 ScmVerbose(pState->pState, 1, "* copyright comment starts in column %u instead of 1\n", pInfo->offStart + 1);
1329 pState->fWellFormedCopyright = false;
1330 /** @todo check that there isn't any code preceeding the comment. */
1331 }
1332
1333 if (pchContributedBy)
1334 {
1335 pState->pszContributedBy = RTStrDupN(pchContributedBy, cchContributedBy);
1336 if (cBlankLinesAfterContributedBy != 1)
1337 {
1338 ScmVerbose(pState->pState, 1, "* %u blank lines between contributed by and copyright, should be 1\n",
1339 cBlankLinesAfterContributedBy);
1340 pState->fWellFormedCopyright = false;
1341 }
1342 }
1343
1344 fFoundCopyright = true;
1345 ScmVerbose(pState->pState, 3, "oracle copyright %u-%u: up-to-date=%RTbool well-formed=%RTbool\n",
1346 pState->uFirstYear, pState->uLastYear, pState->fUpToDateCopyright, pState->fWellFormedCopyright);
1347 }
1348 else
1349 ScmVerbose(pState->pState, 3, "not oracle copyright: '%.*s'\n", pszEnd - pszBody, pszBody);
1350
1351 if (!pszNextLine)
1352 return VINF_SUCCESS;
1353
1354 /* Skip the copyright line and any blank lines following it. */
1355 cchBody -= pszNextLine - pszBody + 1;
1356 pszBody = pszNextLine + 1;
1357 iLine += 1;
1358 while (*pszBody == '\n')
1359 {
1360 pszBody++;
1361 cchBody--;
1362 iLine++;
1363 cBlankLinesAfterCopyright++;
1364 }
1365
1366 /*
1367 * If we have a based-on-mit scenario, check for the lead in now and
1368 * complain if not found.
1369 */
1370 if ( fFoundCopyright
1371 && pState->enmLicenceOpt == kScmLicense_BasedOnMit
1372 && pState->iLineLicense == UINT32_MAX)
1373 {
1374 if (RTStrNICmp(pszBody, RT_STR_TUPLE("This file is based on ")) == 0)
1375 {
1376 /* Take down a comment area which goes up to 'this file is based on'.
1377 The license line and length isn't used but gets set to cover the current line. */
1378 pState->iLineComment = pInfo->iLineStart;
1379 pState->cLinesComment = iLine - pInfo->iLineStart;
1380 pState->iLineLicense = iLine;
1381 pState->cLinesLicense = 1;
1382 pState->fExternalLicense = true;
1383 pState->fIsCorrectLicense = true;
1384 pState->fWellFormedLicense = true;
1385
1386 /* Check if we've got a MIT a license here or not. */
1387 pState->pCurrentLicense = NULL;
1388 do
1389 {
1390 const char *pszEol = (const char *)memchr(pszBody, '\n', cchBody);
1391 if (!pszEol || pszEol[1] == '\0')
1392 {
1393 pszBody += cchBody;
1394 cchBody = 0;
1395 break;
1396 }
1397 cchBody -= pszEol - pszBody + 1;
1398 pszBody = pszEol + 1;
1399 iLine++;
1400
1401 for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
1402 {
1403 const char *pszNext;
1404 if ( pCur->cch <= cchBody + 32 /* (+ 32 since we don't compare spaces and punctuation) */
1405 && IsEqualWordByWordIgnoreCase(pCur->psz, pszBody, &pszNext))
1406 {
1407 pState->pCurrentLicense = pCur;
1408 break;
1409 }
1410 }
1411 } while (!pState->pCurrentLicense);
1412 if (!pState->pCurrentLicense)
1413 ScmError(pState->pState, VERR_NOT_FOUND, "Could not find the based-on license!\n");
1414 else if (pState->pCurrentLicense->enmType != kScmLicenseType_Mit)
1415 ScmError(pState->pState, VERR_NOT_FOUND, "The based-on license is not MIT (%.32s...)\n",
1416 pState->pCurrentLicense->psz);
1417 }
1418 else
1419 ScmError(pState->pState, VERR_WRONG_ORDER, "Expected 'This file is based on ...' after our copyright!\n");
1420 return VINF_SUCCESS;
1421 }
1422 }
1423
1424 /*
1425 * Look for LGPL like text in the comment.
1426 */
1427 if (pState->fCheckforLgpl && cchBody > 128)
1428 {
1429 /* We look for typical LGPL notices. */
1430 if (pState->iLineLgplNotice == UINT32_MAX)
1431 {
1432 static const char * const s_apszFragments[] =
1433 {
1434 "under the terms of the GNU Lesser General Public License",
1435 };
1436 for (unsigned i = 0; i < RT_ELEMENTS(s_apszFragments); i++)
1437 if (scmContainsWordByWordIgnoreCase(pszBody, cchBody, s_apszFragments[i], NULL, NULL))
1438 {
1439 pState->iLineLgplNotice = iLine;
1440 pState->iLineAfterLgplComment = pInfo->iLineEnd + 1;
1441 ScmVerbose(pState->pState, 3, "Found LGPL notice at %u\n", iLine);
1442 break;
1443 }
1444 }
1445
1446 if ( pState->iLineLgplDisclaimer == UINT32_MAX
1447 && scmContainsWordByWordIgnoreCase(pszBody, cchBody, g_szLgplDisclaimer, NULL, NULL))
1448 {
1449 pState->iLineLgplDisclaimer = iLine;
1450 ScmVerbose(pState->pState, 3, "Found LGPL disclaimer at %u\n", iLine);
1451 }
1452 }
1453
1454 /*
1455 * Look for the license text.
1456 */
1457 if (pState->iLineLicense == UINT32_MAX)
1458 {
1459 for (PCSCMLICENSETEXT pCur = pState->paLicenses; pCur->cch > 0; pCur++)
1460 {
1461 const char *pszNext;
1462 if ( pCur->cch <= cchBody + 32 /* (+ 32 since we don't compare spaces and punctuation) */
1463 && IsEqualWordByWordIgnoreCase(pCur->psz, pszBody, &pszNext))
1464 {
1465 while ( RT_C_IS_SPACE(*pszNext)
1466 || (RT_C_IS_PUNCT(*pszNext) && *pszNext != '-'))
1467 pszNext++;
1468
1469 uint32_t cDashes = 0;
1470 while (*pszNext == '-')
1471 cDashes++, pszNext++;
1472 bool fExternal = cDashes > 10;
1473
1474 if ( *pszNext == '\0'
1475 || fExternal)
1476 {
1477 /* In C/C++ code, this must be a multiline comment. While in python it
1478 must be a */
1479 if (pState->enmCommentStyle == kScmCommentStyle_C && pInfo->enmType != kScmCommentType_MultiLine)
1480 ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a multiline comment (no doxygen stuff)\n");
1481 else if (pState->enmCommentStyle == kScmCommentStyle_Python && pInfo->enmType != kScmCommentType_DocString)
1482 ScmError(pState->pState, VERR_WRONG_ORDER, "License must appear in a doc-string\n");
1483
1484 /* Quit if we've flagged a failure. */
1485 if (RT_FAILURE(pState->pState->rc))
1486 return VERR_CALLBACK_RETURN;
1487
1488 /* Record it. */
1489 pState->iLineLicense = iLine;
1490 pState->cLinesLicense = CountLinesInSubstring(pszBody, pszNext - pszBody) - fExternal;
1491 pState->pCurrentLicense = pCur;
1492 pState->fExternalLicense = fExternal;
1493 pState->fIsCorrectLicense = pState->fOpenSource
1494 ? pCur == pState->pExpectedLicense
1495 : pCur->enmType == kScmLicenseType_Confidential;
1496 pState->fWellFormedLicense = memcmp(pszBody, pCur->psz, pCur->cch - 1) == 0;
1497 if (!pState->fWellFormedLicense)
1498 ScmVerbose(pState->pState, 1, "* license text isn't well-formed\n");
1499
1500 /* If there was more than one blank line between the copyright and the
1501 license text, extend the license text area and force a rewrite of it. */
1502 if (cBlankLinesAfterCopyright > 1)
1503 {
1504 ScmVerbose(pState->pState, 1, "* %u blank lines between copyright and license text, instead of 1\n",
1505 cBlankLinesAfterCopyright);
1506 pState->iLineLicense -= cBlankLinesAfterCopyright - 1;
1507 pState->cLinesLicense += cBlankLinesAfterCopyright - 1;
1508 pState->fWellFormedLicense = false;
1509 }
1510
1511 /* If there was more than one blank line after the license, trigger a rewrite. */
1512 if (!fExternal && pInfo->cBlankLinesAfter != 1)
1513 {
1514 ScmVerbose(pState->pState, 1, "* copyright comment is followed by %u blank lines instead of 1\n",
1515 pInfo->cBlankLinesAfter);
1516 pState->fWellFormedLicense = false;
1517 }
1518
1519 /** @todo Check that the last comment line doesn't have any code on it. */
1520 /** @todo Check that column 2 contains '*' for C/C++ files. */
1521
1522 ScmVerbose(pState->pState, 3,
1523 "Found license %d/%d at %u..%u: is-correct=%RTbool well-formed=%RTbool external-part=%RTbool open-source=%RTbool\n",
1524 pCur->enmType, pCur->enmOpt, pState->iLineLicense, pState->iLineLicense + pState->cLinesLicense,
1525 pState->fIsCorrectLicense, pState->fWellFormedLicense,
1526 pState->fExternalLicense, pState->fOpenSource);
1527
1528 if (fFoundCopyright)
1529 {
1530 pState->iLineComment = pInfo->iLineStart;
1531 pState->cLinesComment = (fExternal ? pState->iLineLicense + pState->cLinesLicense : pInfo->iLineEnd + 1)
1532 - pInfo->iLineStart;
1533 }
1534 else
1535 ScmError(pState->pState, VERR_WRONG_ORDER, "License should be preceeded by the copyright!\n");
1536 break;
1537 }
1538 }
1539 }
1540 }
1541
1542 if (fFoundCopyright && pState->iLineLicense == UINT32_MAX)
1543 ScmError(pState->pState, VERR_WRONG_ORDER, "Copyright should be followed by the license text!\n");
1544
1545 /*
1546 * Stop looking for stuff after 100 comments.
1547 */
1548 if (pState->cComments > 100)
1549 return VERR_CALLBACK_RETURN;
1550 return VINF_SUCCESS;
1551}
1552
1553/**
1554 * Writes comment body text.
1555 *
1556 * @returns Stream status.
1557 * @param pOut The output stream.
1558 * @param pszText The text to write.
1559 * @param cchText The length of the text.
1560 * @param enmCommentStyle The comment style.
1561 * @param enmEol The EOL style.
1562 */
1563static int scmWriteCommentBody(PSCMSTREAM pOut, const char *pszText, size_t cchText,
1564 SCMCOMMENTSTYLE enmCommentStyle, SCMEOL enmEol)
1565{
1566 Assert(pszText[cchText - 1] == '\n');
1567 Assert(pszText[cchText - 2] != '\n');
1568 NOREF(cchText);
1569 do
1570 {
1571 const char *pszEol = strchr(pszText, '\n');
1572 if (pszEol != pszText)
1573 {
1574 ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
1575 g_aCopyrightCommentPrefix[enmCommentStyle].cch);
1576 ScmStreamWrite(pOut, pszText, pszEol - pszText);
1577 ScmStreamPutEol(pOut, enmEol);
1578 }
1579 else
1580 ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
1581 g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
1582 pszText = pszEol + 1;
1583 } while (*pszText != '\0');
1584 return ScmStreamGetStatus(pOut);
1585}
1586
1587
1588/**
1589 * Updates the copyright year and/or license text.
1590 *
1591 * @returns true if modifications were made, false if not.
1592 * @param pState The rewriter state.
1593 * @param pIn The input stream.
1594 * @param pOut The output stream.
1595 * @param pSettings The settings.
1596 * @param enmCommentStyle The comment style used by the file.
1597 */
1598static bool rewrite_Copyright_Common(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
1599 SCMCOMMENTSTYLE enmCommentStyle)
1600{
1601 if ( !pSettings->fUpdateCopyrightYear
1602 && pSettings->enmUpdateLicense == kScmLicense_LeaveAlone)
1603 return false;
1604
1605 /*
1606 * Try locate the relevant comments.
1607 */
1608 SCMCOPYRIGHTINFO Info =
1609 {
1610 /*.pState = */ pState,
1611 /*.enmCommentStyle = */ enmCommentStyle,
1612
1613 /*.cComments = */ 0,
1614
1615 /*.pszContributedBy = */ NULL,
1616
1617 /*.iLineComment = */ UINT32_MAX,
1618 /*.cLinesComment = */ 0,
1619
1620 /*.iLineCopyright = */ UINT32_MAX,
1621 /*.uFirstYear = */ UINT32_MAX,
1622 /*.uLastYear = */ UINT32_MAX,
1623 /*.fWellFormedCopyright = */ false,
1624 /*.fUpToDateCopyright = */ false,
1625
1626 /*.fOpenSource = */ true,
1627 /*.pExpectedLicense = */ NULL,
1628 /*.paLicenses = */ pSettings->enmUpdateLicense != kScmLicense_Mit
1629 && pSettings->enmUpdateLicense != kScmLicense_BasedOnMit
1630 ? &g_aLicenses[0] : &g_aLicensesWithMit[0],
1631 /*.enmLicenceOpt = */ pSettings->enmUpdateLicense,
1632 /*.iLineLicense = */ UINT32_MAX,
1633 /*.cLinesLicense = */ 0,
1634 /*.pCurrentLicense = */ NULL,
1635 /*.fIsCorrectLicense = */ false,
1636 /*.fWellFormedLicense = */ false,
1637 /*.fExternalLicense = */ false,
1638
1639 /*.fCheckForLgpl = */ true,
1640 /*.iLineLgplNotice = */ UINT32_MAX,
1641 /*.iLineAfterLgplComment = */ UINT32_MAX,
1642 /*.iLineLgplDisclaimer = */ UINT32_MAX,
1643 };
1644
1645 /* Figure Info.fOpenSource and the desired license: */
1646 char *pszSyncProcess;
1647 int rc = ScmSvnQueryProperty(pState, "svn:sync-process", &pszSyncProcess);
1648 if (RT_SUCCESS(rc))
1649 {
1650 Info.fOpenSource = strcmp(RTStrStrip(pszSyncProcess), "export") == 0;
1651 RTStrFree(pszSyncProcess);
1652 }
1653 else if (rc == VERR_NOT_FOUND)
1654 Info.fOpenSource = false;
1655 else
1656 return ScmError(pState, rc, "ScmSvnQueryProperty(svn:sync-process): %Rrc\n", rc);
1657
1658 Info.pExpectedLicense = Info.paLicenses;
1659 if (Info.fOpenSource)
1660 {
1661 if ( pSettings->enmUpdateLicense != kScmLicense_Mit
1662 && pSettings->enmUpdateLicense != kScmLicense_BasedOnMit)
1663 while (Info.pExpectedLicense->enmOpt != pSettings->enmUpdateLicense)
1664 Info.pExpectedLicense++;
1665 else
1666 Assert(Info.pExpectedLicense->enmOpt == kScmLicense_Mit);
1667 }
1668 else
1669 while (Info.pExpectedLicense->enmType != kScmLicenseType_Confidential)
1670 Info.pExpectedLicense++;
1671
1672 /* Scan the comments. */
1673 rc = ScmEnumerateComments(pIn, enmCommentStyle, rewrite_Copyright_CommentCallback, &Info);
1674 if ( (rc == VERR_CALLBACK_RETURN || RT_SUCCESS(rc))
1675 && RT_SUCCESS(pState->rc))
1676 {
1677 /*
1678 * Do conformity checks.
1679 */
1680 bool fAddLgplDisclaimer = false;
1681 if (Info.fCheckforLgpl)
1682 {
1683 if ( Info.iLineLgplNotice != UINT32_MAX
1684 && Info.iLineLgplDisclaimer == UINT32_MAX)
1685 {
1686 if (!pSettings->fLgplDisclaimer) /** @todo reconcile options with common sense. */
1687 ScmError(pState, VERR_NOT_FOUND, "LGPL licence notice on line %u, but no LGPL disclaimer was found!\n",
1688 Info.iLineLgplNotice + 1);
1689 else
1690 {
1691 ScmVerbose(pState, 1, "* Need to add LGPL disclaimer\n");
1692 fAddLgplDisclaimer = true;
1693 }
1694 }
1695 else if ( Info.iLineLgplNotice == UINT32_MAX
1696 && Info.iLineLgplDisclaimer != UINT32_MAX)
1697 ScmError(pState, VERR_NOT_FOUND, "LGPL disclaimer on line %u, but no LGPL copyright notice!\n",
1698 Info.iLineLgplDisclaimer + 1);
1699 }
1700
1701 if (!pSettings->fExternalCopyright)
1702 {
1703 if (Info.iLineCopyright == UINT32_MAX)
1704 ScmError(pState, VERR_NOT_FOUND, "Missing copyright!\n");
1705 if (Info.iLineLicense == UINT32_MAX)
1706 ScmError(pState, VERR_NOT_FOUND, "Missing license!\n");
1707 }
1708 else if (Info.iLineCopyright != UINT32_MAX)
1709 ScmError(pState, VERR_NOT_FOUND,
1710 "Marked as external copyright only, but found non-external copyright statement at line %u!\n",
1711 Info.iLineCopyright + 1);
1712
1713
1714 if (RT_SUCCESS(pState->rc))
1715 {
1716 /*
1717 * Do we need to make any changes?
1718 */
1719 bool fUpdateCopyright = !pSettings->fExternalCopyright
1720 && ( !Info.fWellFormedCopyright
1721 || (!Info.fUpToDateCopyright && pSettings->fUpdateCopyrightYear));
1722 bool fUpdateLicense = !pSettings->fExternalCopyright
1723 && Info.enmLicenceOpt != kScmLicense_LeaveAlone
1724 && ( !Info.fWellFormedLicense
1725 || !Info.fIsCorrectLicense);
1726 if ( fUpdateCopyright
1727 || fUpdateLicense
1728 || fAddLgplDisclaimer)
1729 {
1730 Assert(Info.iLineComment != UINT32_MAX);
1731 Assert(Info.cLinesComment > 0);
1732
1733 /*
1734 * Okay, do the work.
1735 */
1736 ScmStreamRewindForReading(pIn);
1737
1738 if (pSettings->fUpdateCopyrightYear)
1739 Info.uLastYear = g_uYear;
1740
1741 uint32_t iLine = 0;
1742 SCMEOL enmEol;
1743 size_t cchLine;
1744 const char *pchLine;
1745 while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
1746 {
1747 if ( iLine == Info.iLineComment
1748 && (fUpdateCopyright || fUpdateLicense) )
1749 {
1750 /* Leading blank line. */
1751 ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
1752 g_aCopyrightCommentStart[enmCommentStyle].cch, enmEol);
1753
1754 /* Contributed by someone? */
1755 if (Info.pszContributedBy)
1756 {
1757 const char *psz = Info.pszContributedBy;
1758 for (;;)
1759 {
1760 const char *pszEol = strchr(psz, '\n');
1761 size_t cchContribLine = pszEol ? pszEol - psz : strlen(psz);
1762 ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
1763 g_aCopyrightCommentPrefix[enmCommentStyle].cch);
1764 ScmStreamWrite(pOut, psz, cchContribLine);
1765 ScmStreamPutEol(pOut, enmEol);
1766 if (!pszEol)
1767 break;
1768 psz = pszEol + 1;
1769 }
1770
1771 ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
1772 g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
1773 }
1774
1775 /* Write the copyright comment line. */
1776 ScmStreamWrite(pOut, g_aCopyrightCommentPrefix[enmCommentStyle].psz,
1777 g_aCopyrightCommentPrefix[enmCommentStyle].cch);
1778
1779 char szCopyright[256];
1780 size_t cchCopyright;
1781 if (Info.uFirstYear == Info.uLastYear)
1782 cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u %s",
1783 Info.uFirstYear, g_szCopyrightHolder);
1784 else
1785 cchCopyright = RTStrPrintf(szCopyright, sizeof(szCopyright), "Copyright (C) %u-%u %s",
1786 Info.uFirstYear, Info.uLastYear, g_szCopyrightHolder);
1787
1788 ScmStreamWrite(pOut, szCopyright, cchCopyright);
1789 ScmStreamPutEol(pOut, enmEol);
1790
1791 if (pSettings->enmUpdateLicense != kScmLicense_BasedOnMit)
1792 {
1793 /* Blank line separating the two. */
1794 ScmStreamPutLine(pOut, g_aCopyrightCommentEmpty[enmCommentStyle].psz,
1795 g_aCopyrightCommentEmpty[enmCommentStyle].cch, enmEol);
1796
1797 /* Write the license text. */
1798 scmWriteCommentBody(pOut, Info.pExpectedLicense->psz, Info.pExpectedLicense->cch,
1799 enmCommentStyle, enmEol);
1800
1801 /* Final comment line. */
1802 if (!Info.fExternalLicense)
1803 ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
1804 g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
1805 }
1806 else
1807 Assert(Info.fExternalLicense);
1808
1809 /* Skip the copyright and license text in the input file. */
1810 rc = ScmStreamGetStatus(pOut);
1811 if (RT_SUCCESS(rc))
1812 {
1813 iLine = Info.iLineComment + Info.cLinesComment;
1814 rc = ScmStreamSeekByLine(pIn, iLine);
1815 }
1816 }
1817 /*
1818 * Add LGPL disclaimer?
1819 */
1820 else if ( iLine == Info.iLineAfterLgplComment
1821 && fAddLgplDisclaimer)
1822 {
1823 ScmStreamPutEol(pOut, enmEol);
1824 ScmStreamPutLine(pOut, g_aCopyrightCommentStart[enmCommentStyle].psz,
1825 g_aCopyrightCommentStart[enmCommentStyle].cch, enmEol);
1826 scmWriteCommentBody(pOut, g_szLgplDisclaimer, sizeof(g_szLgplDisclaimer) - 1,
1827 enmCommentStyle, enmEol);
1828 ScmStreamPutLine(pOut, g_aCopyrightCommentEnd[enmCommentStyle].psz,
1829 g_aCopyrightCommentEnd[enmCommentStyle].cch, enmEol);
1830
1831 /* put the actual line */
1832 rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
1833 iLine++;
1834 }
1835 else
1836 {
1837 rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
1838 iLine++;
1839 }
1840 if (RT_FAILURE(rc))
1841 {
1842 RTStrFree(Info.pszContributedBy);
1843 return false;
1844 }
1845 } /* for each source line */
1846
1847 RTStrFree(Info.pszContributedBy);
1848 return true;
1849 }
1850 }
1851 }
1852 else
1853 ScmError(pState, rc, "ScmEnumerateComments: %Rrc\n", rc);
1854 NOREF(pState); NOREF(pOut);
1855 RTStrFree(Info.pszContributedBy);
1856 return false;
1857}
1858
1859
1860/** Copyright updater for C-style comments. */
1861bool rewrite_Copyright_CstyleComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1862{
1863 return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_C);
1864}
1865
1866/** Copyright updater for hash-prefixed comments. */
1867bool rewrite_Copyright_HashComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1868{
1869 return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Hash);
1870}
1871
1872/** Copyright updater for REM-prefixed comments. */
1873bool rewrite_Copyright_RemComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1874{
1875 return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, determinBatchFileCommentStyle(pIn));
1876}
1877
1878/** Copyright updater for python comments. */
1879bool rewrite_Copyright_PythonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1880{
1881 return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Python);
1882}
1883
1884/** Copyright updater for semicolon-prefixed comments. */
1885bool rewrite_Copyright_SemicolonComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1886{
1887 return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Semicolon);
1888}
1889
1890/** Copyright updater for sql comments. */
1891bool rewrite_Copyright_SqlComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1892{
1893 return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Sql);
1894}
1895
1896/** Copyright updater for tick-prefixed comments. */
1897bool rewrite_Copyright_TickComment(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1898{
1899 return rewrite_Copyright_Common(pState, pIn, pOut, pSettings, kScmCommentStyle_Tick);
1900}
1901
1902
1903/**
1904 * Makefile.kup are empty files, enforce this.
1905 *
1906 * @returns true if modifications were made, false if not.
1907 * @param pIn The input stream.
1908 * @param pOut The output stream.
1909 * @param pSettings The settings.
1910 */
1911bool rewrite_Makefile_kup(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1912{
1913 RT_NOREF2(pOut, pSettings);
1914
1915 /* These files should be zero bytes. */
1916 if (pIn->cb == 0)
1917 return false;
1918 ScmVerbose(pState, 2, " * Truncated file to zero bytes\n");
1919 return true;
1920}
1921
1922/**
1923 * Rewrite a kBuild makefile.
1924 *
1925 * @returns true if modifications were made, false if not.
1926 * @param pIn The input stream.
1927 * @param pOut The output stream.
1928 * @param pSettings The settings.
1929 *
1930 * @todo
1931 *
1932 * Ideas for Makefile.kmk and Config.kmk:
1933 * - sort if1of/ifn1of sets.
1934 * - line continuation slashes should only be preceded by one space.
1935 */
1936bool rewrite_Makefile_kmk(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
1937{
1938 RT_NOREF4(pState, pIn, pOut, pSettings);
1939 return false;
1940}
1941
1942
1943static bool isFlowerBoxSectionMarker(PSCMSTREAM pIn, const char *pchLine, size_t cchLine, uint32_t cchWidth,
1944 const char **ppchText, size_t *pcchText, bool *pfNeedFixing)
1945{
1946 *ppchText = NULL;
1947 *pcchText = 0;
1948 *pfNeedFixing = false;
1949
1950 /*
1951 * The first line.
1952 */
1953 if (pchLine[0] != '/')
1954 return false;
1955 size_t offLine = 1;
1956 while (offLine < cchLine && pchLine[offLine] == '*')
1957 offLine++;
1958 if (offLine < 20) /* (Code below depend on a reasonable minimum here.) */
1959 return false;
1960 while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
1961 offLine++;
1962 if (offLine != cchLine)
1963 return false;
1964
1965 size_t const cchBox = cchLine;
1966 *pfNeedFixing = cchBox != cchWidth;
1967
1968 /*
1969 * The next line, extracting the text.
1970 */
1971 SCMEOL enmEol;
1972 pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
1973 if (cchLine < cchBox - 3)
1974 return false;
1975
1976 offLine = 0;
1977 if (RT_C_IS_BLANK(pchLine[0]))
1978 {
1979 *pfNeedFixing = true;
1980 offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
1981 }
1982
1983 if (pchLine[offLine] != '*')
1984 return false;
1985 offLine++;
1986
1987 if (!RT_C_IS_BLANK(pchLine[offLine + 1]))
1988 return false;
1989 offLine++;
1990
1991 while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
1992 offLine++;
1993 if (offLine >= cchLine)
1994 return false;
1995 if (!RT_C_IS_UPPER(pchLine[offLine]))
1996 return false;
1997
1998 if (offLine != 4 || cchLine != cchBox)
1999 *pfNeedFixing = true;
2000
2001 *ppchText = &pchLine[offLine];
2002 size_t const offText = offLine;
2003
2004 /* From the end now. */
2005 offLine = cchLine - 1;
2006 while (RT_C_IS_BLANK(pchLine[offLine]))
2007 offLine--;
2008
2009 if (pchLine[offLine] != '*')
2010 return false;
2011 offLine--;
2012 if (!RT_C_IS_BLANK(pchLine[offLine]))
2013 return false;
2014 offLine--;
2015 while (RT_C_IS_BLANK(pchLine[offLine]))
2016 offLine--;
2017 *pcchText = offLine - offText + 1;
2018
2019 /*
2020 * Third line closes the box.
2021 */
2022 pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
2023 if (cchLine < cchBox - 3)
2024 return false;
2025
2026 offLine = 0;
2027 if (RT_C_IS_BLANK(pchLine[0]))
2028 {
2029 *pfNeedFixing = true;
2030 offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
2031 }
2032 while (offLine < cchLine && pchLine[offLine] == '*')
2033 offLine++;
2034 if (offLine < cchBox - 4)
2035 return false;
2036
2037 if (pchLine[offLine] != '/')
2038 return false;
2039 offLine++;
2040
2041 if (offLine != cchBox)
2042 *pfNeedFixing = true;
2043
2044 while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
2045 offLine++;
2046 if (offLine != cchLine)
2047 return false;
2048
2049 return true;
2050}
2051
2052
2053/**
2054 * Flower box marker comments in C and C++ code.
2055 *
2056 * @returns true if modifications were made, false if not.
2057 * @param pIn The input stream.
2058 * @param pOut The output stream.
2059 * @param pSettings The settings.
2060 */
2061bool rewrite_FixFlowerBoxMarkers(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2062{
2063 if (!pSettings->fFixFlowerBoxMarkers)
2064 return false;
2065
2066 /*
2067 * Work thru the file line by line looking for flower box markers.
2068 */
2069 size_t cChanges = 0;
2070 size_t cBlankLines = 0;
2071 SCMEOL enmEol;
2072 size_t cchLine;
2073 const char *pchLine;
2074 while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
2075 {
2076 /*
2077 * Get a likely match for a first line.
2078 */
2079 if ( pchLine[0] == '/'
2080 && cchLine > 20
2081 && pchLine[1] == '*'
2082 && pchLine[2] == '*'
2083 && pchLine[3] == '*')
2084 {
2085 size_t const offSaved = ScmStreamTell(pIn);
2086 char const *pchText;
2087 size_t cchText;
2088 bool fNeedFixing;
2089 bool fIsFlowerBoxSection = isFlowerBoxSectionMarker(pIn, pchLine, cchLine, pSettings->cchWidth,
2090 &pchText, &cchText, &fNeedFixing);
2091 if ( fIsFlowerBoxSection
2092 && ( fNeedFixing
2093 || cBlankLines < pSettings->cMinBlankLinesBeforeFlowerBoxMakers) )
2094 {
2095 while (cBlankLines < pSettings->cMinBlankLinesBeforeFlowerBoxMakers)
2096 {
2097 ScmStreamPutEol(pOut, enmEol);
2098 cBlankLines++;
2099 }
2100
2101 ScmStreamPutCh(pOut, '/');
2102 ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
2103 ScmStreamPutEol(pOut, enmEol);
2104
2105 static const char s_szLead[] = "* ";
2106 ScmStreamWrite(pOut, s_szLead, sizeof(s_szLead) - 1);
2107 ScmStreamWrite(pOut, pchText, cchText);
2108 size_t offCurPlus1 = sizeof(s_szLead) - 1 + cchText + 1;
2109 ScmStreamWrite(pOut, g_szSpaces, offCurPlus1 < pSettings->cchWidth ? pSettings->cchWidth - offCurPlus1 : 1);
2110 ScmStreamPutCh(pOut, '*');
2111 ScmStreamPutEol(pOut, enmEol);
2112
2113 ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
2114 ScmStreamPutCh(pOut, '/');
2115 ScmStreamPutEol(pOut, enmEol);
2116
2117 cChanges++;
2118 cBlankLines = 0;
2119 continue;
2120 }
2121
2122 int rc = ScmStreamSeekAbsolute(pIn, offSaved);
2123 if (RT_FAILURE(rc))
2124 return false;
2125 }
2126
2127 int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
2128 if (RT_FAILURE(rc))
2129 return false;
2130
2131 /* Do blank line accounting so we can ensure at least two blank lines
2132 before each section marker. */
2133 if (!isBlankLine(pchLine, cchLine))
2134 cBlankLines = 0;
2135 else
2136 cBlankLines++;
2137 }
2138 if (cChanges > 0)
2139 ScmVerbose(pState, 2, " * Converted %zu flower boxer markers\n", cChanges);
2140 return cChanges != 0;
2141}
2142
2143
2144/**
2145 * Looks for the start of a todo comment.
2146 *
2147 * @returns Offset into the line of the comment start sequence.
2148 * @param pchLine The line to search.
2149 * @param cchLineBeforeTodo The length of the line before the todo.
2150 * @param pfSameLine Indicates whether it's refering to a statemtn on
2151 * the same line comment (true), or the next
2152 * statement (false).
2153 */
2154static size_t findTodoCommentStart(char const *pchLine, size_t cchLineBeforeTodo, bool *pfSameLine)
2155{
2156 *pfSameLine = false;
2157
2158 /* Skip one '@' or '\\'. */
2159 char ch;
2160 if ( cchLineBeforeTodo > 2
2161 && ( (ch = pchLine[cchLineBeforeTodo - 1] == '@')
2162 || ch == '\\' ) )
2163 cchLineBeforeTodo--;
2164
2165 /* Skip blanks. */
2166 while ( cchLineBeforeTodo > 2
2167 && RT_C_IS_BLANK(pchLine[cchLineBeforeTodo - 1]))
2168 cchLineBeforeTodo--;
2169
2170 /* Look for same line indicator. */
2171 if ( cchLineBeforeTodo > 0
2172 && pchLine[cchLineBeforeTodo - 1] == '<')
2173 {
2174 *pfSameLine = true;
2175 cchLineBeforeTodo--;
2176 }
2177
2178 /* Skip *s */
2179 while ( cchLineBeforeTodo > 1
2180 && pchLine[cchLineBeforeTodo - 1] == '*')
2181 cchLineBeforeTodo--;
2182
2183 /* Do we have a comment opening sequence. */
2184 if ( cchLineBeforeTodo > 0
2185 && pchLine[cchLineBeforeTodo - 1] == '/'
2186 && ( ( cchLineBeforeTodo >= 2
2187 && pchLine[cchLineBeforeTodo - 2] == '/')
2188 || pchLine[cchLineBeforeTodo] == '*'))
2189 {
2190 /* Skip slashes at the start. */
2191 while ( cchLineBeforeTodo > 0
2192 && pchLine[cchLineBeforeTodo - 1] == '/')
2193 cchLineBeforeTodo--;
2194
2195 return cchLineBeforeTodo;
2196 }
2197
2198 return ~(size_t)0;
2199}
2200
2201
2202/**
2203 * Looks for a TODO or todo in the given line.
2204 *
2205 * @returns Offset into the line of found, ~(size_t)0 if not.
2206 * @param pchLine The line to search.
2207 * @param cchLine The length of the line.
2208 */
2209static size_t findTodo(char const *pchLine, size_t cchLine)
2210{
2211 if (cchLine >= 4 + 2)
2212 {
2213 /* We don't search the first to chars because we need the start of a comment.
2214 Also, skip the last three chars since we need at least four for a match. */
2215 size_t const cchLineT = cchLine - 3;
2216 if ( memchr(pchLine + 2, 't', cchLineT - 2) != NULL
2217 || memchr(pchLine + 2, 'T', cchLineT - 2) != NULL)
2218 {
2219 for (size_t off = 2; off < cchLineT; off++)
2220 {
2221 char ch = pchLine[off];
2222 if ( ( ch != 't'
2223 && ch != 'T')
2224 || ( (ch = pchLine[off + 1]) != 'o'
2225 && ch != 'O')
2226 || ( (ch = pchLine[off + 2]) != 'd'
2227 && ch != 'D')
2228 || ( (ch = pchLine[off + 3]) != 'o'
2229 && ch != 'O')
2230 || ( off + 4 != cchLine
2231 && (ch = pchLine[off + 4]) != ' '
2232 && ch != '\t'
2233 && ch != ':' /** @todo */
2234 && (ch != '*' || off + 5 > cchLine || pchLine[off + 5] != '/') /** @todo */
2235 ) )
2236 { /* not a hit - likely */ }
2237 else
2238 return off;
2239 }
2240 }
2241 }
2242 return ~(size_t)0;
2243}
2244
2245
2246/**
2247 * Flower box marker comments in C and C++ code.
2248 *
2249 * @returns true if modifications were made, false if not.
2250 * @param pIn The input stream.
2251 * @param pOut The output stream.
2252 * @param pSettings The settings.
2253 */
2254bool rewrite_Fix_C_and_CPP_Todos(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2255{
2256 if (!pSettings->fFixTodos)
2257 return false;
2258
2259 /*
2260 * Work thru the file line by line looking for the start of todo comments.
2261 */
2262 size_t cChanges = 0;
2263 SCMEOL enmEol;
2264 size_t cchLine;
2265 const char *pchLine;
2266 while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
2267 {
2268 /*
2269 * Look for the word 'todo' in the line. We're currently only trying
2270 * to catch comments starting with the word todo and adjust the start of
2271 * the doxygen statement.
2272 */
2273 size_t offTodo = findTodo(pchLine, cchLine);
2274 if ( offTodo != ~(size_t)0
2275 && offTodo >= 2)
2276 {
2277 /* Work backwards to find the start of the comment. */
2278 bool fSameLine = false;
2279 size_t offCommentStart = findTodoCommentStart(pchLine, offTodo, &fSameLine);
2280 if (offCommentStart != ~(size_t)0)
2281 {
2282 char szNew[64];
2283 size_t cchNew = 0;
2284 szNew[cchNew++] = '/';
2285 szNew[cchNew++] = pchLine[offCommentStart + 1];
2286 szNew[cchNew++] = pchLine[offCommentStart + 1];
2287 if (fSameLine)
2288 szNew[cchNew++] = '<';
2289 szNew[cchNew++] = ' ';
2290 szNew[cchNew++] = '@';
2291 szNew[cchNew++] = 't';
2292 szNew[cchNew++] = 'o';
2293 szNew[cchNew++] = 'd';
2294 szNew[cchNew++] = 'o';
2295
2296 /* Figure out wheter to continue after the @todo statement opening, we'll strip ':'
2297 but need to take into account that we might be at the end of the line before
2298 adding the space. */
2299 size_t offTodoAfter = offTodo + 4;
2300 if ( offTodoAfter < cchLine
2301 && pchLine[offTodoAfter] == ':')
2302 offTodoAfter++;
2303 if ( offTodoAfter < cchLine
2304 && RT_C_IS_BLANK(pchLine[offTodoAfter]))
2305 offTodoAfter++;
2306 if (offTodoAfter < cchLine)
2307 szNew[cchNew++] = ' ';
2308
2309 /* Write it out. */
2310 ScmStreamWrite(pOut, pchLine, offCommentStart);
2311 ScmStreamWrite(pOut, szNew, cchNew);
2312 if (offTodoAfter < cchLine)
2313 ScmStreamWrite(pOut, &pchLine[offTodoAfter], cchLine - offTodoAfter);
2314 ScmStreamPutEol(pOut, enmEol);
2315
2316 /* Check whether we actually made any changes. */
2317 if ( cchNew != offTodoAfter - offCommentStart
2318 || memcmp(szNew, &pchLine[offCommentStart], cchNew))
2319 cChanges++;
2320 continue;
2321 }
2322 }
2323
2324 int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
2325 if (RT_FAILURE(rc))
2326 return false;
2327 }
2328 if (cChanges > 0)
2329 ScmVerbose(pState, 2, " * Converted %zu todo statements.\n", cChanges);
2330 return cChanges != 0;
2331}
2332
2333
2334/**
2335 * Rewrite a C/C++ source or header file.
2336 *
2337 * @returns true if modifications were made, false if not.
2338 * @param pIn The input stream.
2339 * @param pOut The output stream.
2340 * @param pSettings The settings.
2341 *
2342 * @todo
2343 *
2344 * Ideas for C/C++:
2345 * - space after if, while, for, switch
2346 * - spaces in for (i=0;i<x;i++)
2347 * - complex conditional, bird style.
2348 * - remove unnecessary parentheses.
2349 * - sort defined RT_OS_*|| and RT_ARCH
2350 * - sizeof without parenthesis.
2351 * - defined without parenthesis.
2352 * - trailing spaces.
2353 * - parameter indentation.
2354 * - space after comma.
2355 * - while (x--); -> multi line + comment.
2356 * - else statement;
2357 * - space between function and left parenthesis.
2358 * - TODO, XXX, @todo cleanup.
2359 * - Space before/after '*'.
2360 * - ensure new line at end of file.
2361 * - Indentation of precompiler statements (#ifdef, #defines).
2362 * - space between functions.
2363 * - string.h -> iprt/string.h, stdarg.h -> iprt/stdarg.h, etc.
2364 */
2365bool rewrite_C_and_CPP(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
2366{
2367
2368 RT_NOREF4(pState, pIn, pOut, pSettings);
2369 return false;
2370}
2371
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use