1 | /* $Id: scmrw.cpp 57367 2015-08-14 18:02:49Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT Testcase / Tool - Source Code Massager.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2010-2015 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 | * Worker for isBlankLine.
|
---|
43 | *
|
---|
44 | * @returns true if blank, false if not.
|
---|
45 | * @param pchLine Pointer to the start of the line.
|
---|
46 | * @param cchLine The (encoded) length of the line, excluding EOL char.
|
---|
47 | */
|
---|
48 | static bool isBlankLineSlow(const char *pchLine, size_t cchLine)
|
---|
49 | {
|
---|
50 | /*
|
---|
51 | * From the end, more likely to hit a non-blank char there.
|
---|
52 | */
|
---|
53 | while (cchLine-- > 0)
|
---|
54 | if (!RT_C_IS_BLANK(pchLine[cchLine]))
|
---|
55 | return false;
|
---|
56 | return true;
|
---|
57 | }
|
---|
58 |
|
---|
59 | /**
|
---|
60 | * Helper for checking whether a line is blank.
|
---|
61 | *
|
---|
62 | * @returns true if blank, false if not.
|
---|
63 | * @param pchLine Pointer to the start of the line.
|
---|
64 | * @param cchLine The (encoded) length of the line, excluding EOL char.
|
---|
65 | */
|
---|
66 | DECLINLINE(bool) isBlankLine(const char *pchLine, size_t cchLine)
|
---|
67 | {
|
---|
68 | if (cchLine == 0)
|
---|
69 | return true;
|
---|
70 | /*
|
---|
71 | * We're more likely to fine a non-space char at the end of the line than
|
---|
72 | * at the start, due to source code indentation.
|
---|
73 | */
|
---|
74 | if (pchLine[cchLine - 1])
|
---|
75 | return false;
|
---|
76 |
|
---|
77 | /*
|
---|
78 | * Don't bother inlining loop code.
|
---|
79 | */
|
---|
80 | return isBlankLineSlow(pchLine, cchLine);
|
---|
81 | }
|
---|
82 |
|
---|
83 |
|
---|
84 | /**
|
---|
85 | * Strip trailing blanks (space & tab).
|
---|
86 | *
|
---|
87 | * @returns True if modified, false if not.
|
---|
88 | * @param pIn The input stream.
|
---|
89 | * @param pOut The output stream.
|
---|
90 | * @param pSettings The settings.
|
---|
91 | */
|
---|
92 | bool rewrite_StripTrailingBlanks(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
93 | {
|
---|
94 | if (!pSettings->fStripTrailingBlanks)
|
---|
95 | return false;
|
---|
96 |
|
---|
97 | bool fModified = false;
|
---|
98 | SCMEOL enmEol;
|
---|
99 | size_t cchLine;
|
---|
100 | const char *pchLine;
|
---|
101 | while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
|
---|
102 | {
|
---|
103 | int rc;
|
---|
104 | if ( cchLine == 0
|
---|
105 | || !RT_C_IS_BLANK(pchLine[cchLine - 1]) )
|
---|
106 | rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
|
---|
107 | else
|
---|
108 | {
|
---|
109 | cchLine--;
|
---|
110 | while (cchLine > 0 && RT_C_IS_BLANK(pchLine[cchLine - 1]))
|
---|
111 | cchLine--;
|
---|
112 | rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
|
---|
113 | fModified = true;
|
---|
114 | }
|
---|
115 | if (RT_FAILURE(rc))
|
---|
116 | return false;
|
---|
117 | }
|
---|
118 | if (fModified)
|
---|
119 | ScmVerbose(pState, 2, " * Stripped trailing blanks\n");
|
---|
120 | return fModified;
|
---|
121 | }
|
---|
122 |
|
---|
123 | /**
|
---|
124 | * Expand tabs.
|
---|
125 | *
|
---|
126 | * @returns True if modified, false if not.
|
---|
127 | * @param pIn The input stream.
|
---|
128 | * @param pOut The output stream.
|
---|
129 | * @param pSettings The settings.
|
---|
130 | */
|
---|
131 | bool rewrite_ExpandTabs(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
132 | {
|
---|
133 | if (!pSettings->fConvertTabs)
|
---|
134 | return false;
|
---|
135 |
|
---|
136 | size_t const cchTab = pSettings->cchTab;
|
---|
137 | bool fModified = false;
|
---|
138 | SCMEOL enmEol;
|
---|
139 | size_t cchLine;
|
---|
140 | const char *pchLine;
|
---|
141 | while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
|
---|
142 | {
|
---|
143 | int rc;
|
---|
144 | const char *pchTab = (const char *)memchr(pchLine, '\t', cchLine);
|
---|
145 | if (!pchTab)
|
---|
146 | rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
|
---|
147 | else
|
---|
148 | {
|
---|
149 | size_t offTab = 0;
|
---|
150 | const char *pchChunk = pchLine;
|
---|
151 | for (;;)
|
---|
152 | {
|
---|
153 | size_t cchChunk = pchTab - pchChunk;
|
---|
154 | offTab += cchChunk;
|
---|
155 | ScmStreamWrite(pOut, pchChunk, cchChunk);
|
---|
156 |
|
---|
157 | size_t cchToTab = cchTab - offTab % cchTab;
|
---|
158 | ScmStreamWrite(pOut, g_szTabSpaces, cchToTab);
|
---|
159 | offTab += cchToTab;
|
---|
160 |
|
---|
161 | pchChunk = pchTab + 1;
|
---|
162 | size_t cchLeft = cchLine - (pchChunk - pchLine);
|
---|
163 | pchTab = (const char *)memchr(pchChunk, '\t', cchLeft);
|
---|
164 | if (!pchTab)
|
---|
165 | {
|
---|
166 | rc = ScmStreamPutLine(pOut, pchChunk, cchLeft, enmEol);
|
---|
167 | break;
|
---|
168 | }
|
---|
169 | }
|
---|
170 |
|
---|
171 | fModified = true;
|
---|
172 | }
|
---|
173 | if (RT_FAILURE(rc))
|
---|
174 | return false;
|
---|
175 | }
|
---|
176 | if (fModified)
|
---|
177 | ScmVerbose(pState, 2, " * Expanded tabs\n");
|
---|
178 | return fModified;
|
---|
179 | }
|
---|
180 |
|
---|
181 | /**
|
---|
182 | * Worker for rewrite_ForceNativeEol, rewrite_ForceLF and rewrite_ForceCRLF.
|
---|
183 | *
|
---|
184 | * @returns true if modifications were made, false if not.
|
---|
185 | * @param pIn The input stream.
|
---|
186 | * @param pOut The output stream.
|
---|
187 | * @param pSettings The settings.
|
---|
188 | * @param enmDesiredEol The desired end of line indicator type.
|
---|
189 | * @param pszDesiredSvnEol The desired svn:eol-style.
|
---|
190 | */
|
---|
191 | static bool rewrite_ForceEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings,
|
---|
192 | SCMEOL enmDesiredEol, const char *pszDesiredSvnEol)
|
---|
193 | {
|
---|
194 | if (!pSettings->fConvertEol)
|
---|
195 | return false;
|
---|
196 |
|
---|
197 | bool fModified = false;
|
---|
198 | SCMEOL enmEol;
|
---|
199 | size_t cchLine;
|
---|
200 | const char *pchLine;
|
---|
201 | while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
|
---|
202 | {
|
---|
203 | if ( enmEol != enmDesiredEol
|
---|
204 | && enmEol != SCMEOL_NONE)
|
---|
205 | {
|
---|
206 | fModified = true;
|
---|
207 | enmEol = enmDesiredEol;
|
---|
208 | }
|
---|
209 | int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
|
---|
210 | if (RT_FAILURE(rc))
|
---|
211 | return false;
|
---|
212 | }
|
---|
213 | if (fModified)
|
---|
214 | ScmVerbose(pState, 2, " * Converted EOL markers\n");
|
---|
215 |
|
---|
216 | /* Check svn:eol-style if appropriate */
|
---|
217 | if ( pSettings->fSetSvnEol
|
---|
218 | && ScmSvnIsInWorkingCopy(pState))
|
---|
219 | {
|
---|
220 | char *pszEol;
|
---|
221 | int rc = ScmSvnQueryProperty(pState, "svn:eol-style", &pszEol);
|
---|
222 | if ( (RT_SUCCESS(rc) && strcmp(pszEol, pszDesiredSvnEol))
|
---|
223 | || rc == VERR_NOT_FOUND)
|
---|
224 | {
|
---|
225 | if (rc == VERR_NOT_FOUND)
|
---|
226 | ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (missing)\n", pszDesiredSvnEol);
|
---|
227 | else
|
---|
228 | ScmVerbose(pState, 2, " * Setting svn:eol-style to %s (was: %s)\n", pszDesiredSvnEol, pszEol);
|
---|
229 | int rc2 = ScmSvnSetProperty(pState, "svn:eol-style", pszDesiredSvnEol);
|
---|
230 | if (RT_FAILURE(rc2))
|
---|
231 | RTMsgError("ScmSvnSetProperty: %Rrc\n", rc2); /** @todo propagate the error somehow... */
|
---|
232 | }
|
---|
233 | if (RT_SUCCESS(rc))
|
---|
234 | RTStrFree(pszEol);
|
---|
235 | }
|
---|
236 |
|
---|
237 | /** @todo also check the subversion svn:eol-style state! */
|
---|
238 | return fModified;
|
---|
239 | }
|
---|
240 |
|
---|
241 | /**
|
---|
242 | * Force native end of line indicator.
|
---|
243 | *
|
---|
244 | * @returns true if modifications were made, false if not.
|
---|
245 | * @param pIn The input stream.
|
---|
246 | * @param pOut The output stream.
|
---|
247 | * @param pSettings The settings.
|
---|
248 | */
|
---|
249 | bool rewrite_ForceNativeEol(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
250 | {
|
---|
251 | #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
|
---|
252 | return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "native");
|
---|
253 | #else
|
---|
254 | return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF, "native");
|
---|
255 | #endif
|
---|
256 | }
|
---|
257 |
|
---|
258 | /**
|
---|
259 | * Force the stream to use LF as the end of line indicator.
|
---|
260 | *
|
---|
261 | * @returns true if modifications were made, false if not.
|
---|
262 | * @param pIn The input stream.
|
---|
263 | * @param pOut The output stream.
|
---|
264 | * @param pSettings The settings.
|
---|
265 | */
|
---|
266 | bool rewrite_ForceLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
267 | {
|
---|
268 | return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_LF, "LF");
|
---|
269 | }
|
---|
270 |
|
---|
271 | /**
|
---|
272 | * Force the stream to use CRLF as the end of line indicator.
|
---|
273 | *
|
---|
274 | * @returns true if modifications were made, false if not.
|
---|
275 | * @param pIn The input stream.
|
---|
276 | * @param pOut The output stream.
|
---|
277 | * @param pSettings The settings.
|
---|
278 | */
|
---|
279 | bool rewrite_ForceCRLF(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
280 | {
|
---|
281 | return rewrite_ForceEol(pState, pIn, pOut, pSettings, SCMEOL_CRLF, "CRLF");
|
---|
282 | }
|
---|
283 |
|
---|
284 | /**
|
---|
285 | * Strip trailing blank lines and/or make sure there is exactly one blank line
|
---|
286 | * at the end of the file.
|
---|
287 | *
|
---|
288 | * @returns true if modifications were made, false if not.
|
---|
289 | * @param pIn The input stream.
|
---|
290 | * @param pOut The output stream.
|
---|
291 | * @param pSettings The settings.
|
---|
292 | *
|
---|
293 | * @remarks ASSUMES trailing white space has been removed already.
|
---|
294 | */
|
---|
295 | bool rewrite_AdjustTrailingLines(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
296 | {
|
---|
297 | if ( !pSettings->fStripTrailingLines
|
---|
298 | && !pSettings->fForceTrailingLine
|
---|
299 | && !pSettings->fForceFinalEol)
|
---|
300 | return false;
|
---|
301 |
|
---|
302 | size_t const cLines = ScmStreamCountLines(pIn);
|
---|
303 |
|
---|
304 | /* Empty files remains empty. */
|
---|
305 | if (cLines <= 1)
|
---|
306 | return false;
|
---|
307 |
|
---|
308 | /* Figure out if we need to adjust the number of lines or not. */
|
---|
309 | size_t cLinesNew = cLines;
|
---|
310 |
|
---|
311 | if ( pSettings->fStripTrailingLines
|
---|
312 | && ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
|
---|
313 | {
|
---|
314 | while ( cLinesNew > 1
|
---|
315 | && ScmStreamIsWhiteLine(pIn, cLinesNew - 2))
|
---|
316 | cLinesNew--;
|
---|
317 | }
|
---|
318 |
|
---|
319 | if ( pSettings->fForceTrailingLine
|
---|
320 | && !ScmStreamIsWhiteLine(pIn, cLinesNew - 1))
|
---|
321 | cLinesNew++;
|
---|
322 |
|
---|
323 | bool fFixMissingEol = pSettings->fForceFinalEol
|
---|
324 | && ScmStreamGetEolByLine(pIn, cLinesNew - 1) == SCMEOL_NONE;
|
---|
325 |
|
---|
326 | if ( !fFixMissingEol
|
---|
327 | && cLines == cLinesNew)
|
---|
328 | return false;
|
---|
329 |
|
---|
330 | /* Copy the number of lines we've arrived at. */
|
---|
331 | ScmStreamRewindForReading(pIn);
|
---|
332 |
|
---|
333 | size_t cCopied = RT_MIN(cLinesNew, cLines);
|
---|
334 | ScmStreamCopyLines(pOut, pIn, cCopied);
|
---|
335 |
|
---|
336 | if (cCopied != cLinesNew)
|
---|
337 | {
|
---|
338 | while (cCopied++ < cLinesNew)
|
---|
339 | ScmStreamPutLine(pOut, "", 0, ScmStreamGetEol(pIn));
|
---|
340 | }
|
---|
341 | /* Fix missing EOL if required. */
|
---|
342 | else if (fFixMissingEol)
|
---|
343 | {
|
---|
344 | if (ScmStreamGetEol(pIn) == SCMEOL_LF)
|
---|
345 | ScmStreamWrite(pOut, "\n", 1);
|
---|
346 | else
|
---|
347 | ScmStreamWrite(pOut, "\r\n", 2);
|
---|
348 | }
|
---|
349 |
|
---|
350 | ScmVerbose(pState, 2, " * Adjusted trailing blank lines\n");
|
---|
351 | return true;
|
---|
352 | }
|
---|
353 |
|
---|
354 | /**
|
---|
355 | * Make sure there is no svn:executable keyword on the current file.
|
---|
356 | *
|
---|
357 | * @returns false - the state carries these kinds of changes.
|
---|
358 | * @param pState The rewriter state.
|
---|
359 | * @param pIn The input stream.
|
---|
360 | * @param pOut The output stream.
|
---|
361 | * @param pSettings The settings.
|
---|
362 | */
|
---|
363 | bool rewrite_SvnNoExecutable(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
364 | {
|
---|
365 | if ( !pSettings->fSetSvnExecutable
|
---|
366 | || !ScmSvnIsInWorkingCopy(pState))
|
---|
367 | return false;
|
---|
368 |
|
---|
369 | int rc = ScmSvnQueryProperty(pState, "svn:executable", NULL);
|
---|
370 | if (RT_SUCCESS(rc))
|
---|
371 | {
|
---|
372 | ScmVerbose(pState, 2, " * removing svn:executable\n");
|
---|
373 | rc = ScmSvnDelProperty(pState, "svn:executable");
|
---|
374 | if (RT_FAILURE(rc))
|
---|
375 | RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
|
---|
376 | }
|
---|
377 | return false;
|
---|
378 | }
|
---|
379 |
|
---|
380 | /**
|
---|
381 | * Make sure the Id and Revision keywords are expanded.
|
---|
382 | *
|
---|
383 | * @returns false - the state carries these kinds of changes.
|
---|
384 | * @param pState The rewriter state.
|
---|
385 | * @param pIn The input stream.
|
---|
386 | * @param pOut The output stream.
|
---|
387 | * @param pSettings The settings.
|
---|
388 | */
|
---|
389 | bool rewrite_SvnKeywords(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
390 | {
|
---|
391 | if ( !pSettings->fSetSvnKeywords
|
---|
392 | || !ScmSvnIsInWorkingCopy(pState))
|
---|
393 | return false;
|
---|
394 |
|
---|
395 | char *pszKeywords;
|
---|
396 | int rc = ScmSvnQueryProperty(pState, "svn:keywords", &pszKeywords);
|
---|
397 | if ( RT_SUCCESS(rc)
|
---|
398 | && ( !strstr(pszKeywords, "Id") /** @todo need some function for finding a word in a string. */
|
---|
399 | || !strstr(pszKeywords, "Revision")) )
|
---|
400 | {
|
---|
401 | if (!strstr(pszKeywords, "Id") && !strstr(pszKeywords, "Revision"))
|
---|
402 | rc = RTStrAAppend(&pszKeywords, " Id Revision");
|
---|
403 | else if (!strstr(pszKeywords, "Id"))
|
---|
404 | rc = RTStrAAppend(&pszKeywords, " Id");
|
---|
405 | else
|
---|
406 | rc = RTStrAAppend(&pszKeywords, " Revision");
|
---|
407 | if (RT_SUCCESS(rc))
|
---|
408 | {
|
---|
409 | ScmVerbose(pState, 2, " * changing svn:keywords to '%s'\n", pszKeywords);
|
---|
410 | rc = ScmSvnSetProperty(pState, "svn:keywords", pszKeywords);
|
---|
411 | if (RT_FAILURE(rc))
|
---|
412 | RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
|
---|
413 | }
|
---|
414 | else
|
---|
415 | RTMsgError("RTStrAppend: %Rrc\n", rc); /** @todo error propagation here.. */
|
---|
416 | RTStrFree(pszKeywords);
|
---|
417 | }
|
---|
418 | else if (rc == VERR_NOT_FOUND)
|
---|
419 | {
|
---|
420 | ScmVerbose(pState, 2, " * setting svn:keywords to 'Id Revision'\n");
|
---|
421 | rc = ScmSvnSetProperty(pState, "svn:keywords", "Id Revision");
|
---|
422 | if (RT_FAILURE(rc))
|
---|
423 | RTMsgError("ScmSvnSetProperty: %Rrc\n", rc); /** @todo error propagation here.. */
|
---|
424 | }
|
---|
425 | else if (RT_SUCCESS(rc))
|
---|
426 | RTStrFree(pszKeywords);
|
---|
427 |
|
---|
428 | return false;
|
---|
429 | }
|
---|
430 |
|
---|
431 | /**
|
---|
432 | * Makefile.kup are empty files, enforce this.
|
---|
433 | *
|
---|
434 | * @returns true if modifications were made, false if not.
|
---|
435 | * @param pIn The input stream.
|
---|
436 | * @param pOut The output stream.
|
---|
437 | * @param pSettings The settings.
|
---|
438 | */
|
---|
439 | bool rewrite_Makefile_kup(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
440 | {
|
---|
441 | /* These files should be zero bytes. */
|
---|
442 | if (pIn->cb == 0)
|
---|
443 | return false;
|
---|
444 | ScmVerbose(pState, 2, " * Truncated file to zero bytes\n");
|
---|
445 | return true;
|
---|
446 | }
|
---|
447 |
|
---|
448 | /**
|
---|
449 | * Rewrite a kBuild makefile.
|
---|
450 | *
|
---|
451 | * @returns true if modifications were made, false if not.
|
---|
452 | * @param pIn The input stream.
|
---|
453 | * @param pOut The output stream.
|
---|
454 | * @param pSettings The settings.
|
---|
455 | *
|
---|
456 | * @todo
|
---|
457 | *
|
---|
458 | * Ideas for Makefile.kmk and Config.kmk:
|
---|
459 | * - sort if1of/ifn1of sets.
|
---|
460 | * - line continuation slashes should only be preceded by one space.
|
---|
461 | */
|
---|
462 | bool rewrite_Makefile_kmk(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
463 | {
|
---|
464 | return false;
|
---|
465 | }
|
---|
466 |
|
---|
467 |
|
---|
468 | static bool isFlowerBoxSectionMarker(PSCMSTREAM pIn, const char *pchLine, size_t cchLine,
|
---|
469 | const char **ppchText, size_t *pcchText)
|
---|
470 | {
|
---|
471 | *ppchText = NULL;
|
---|
472 | *pcchText = 0;
|
---|
473 |
|
---|
474 | /*
|
---|
475 | * The first line.
|
---|
476 | */
|
---|
477 | if (pchLine[0] != '/')
|
---|
478 | return false;
|
---|
479 | size_t offLine = 1;
|
---|
480 | while (offLine < cchLine && pchLine[offLine] == '*')
|
---|
481 | offLine++;
|
---|
482 | if (offLine < 20) /* (Code below depend on a reasonable minimum here.) */
|
---|
483 | return false;
|
---|
484 | while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
|
---|
485 | offLine++;
|
---|
486 | if (offLine != cchLine)
|
---|
487 | return false;
|
---|
488 |
|
---|
489 | size_t const cchBox = cchLine;
|
---|
490 |
|
---|
491 | /*
|
---|
492 | * The next line, extracting the text.
|
---|
493 | */
|
---|
494 | SCMEOL enmEol;
|
---|
495 | pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
|
---|
496 | if (cchLine < cchBox - 3)
|
---|
497 | return false;
|
---|
498 |
|
---|
499 | offLine = 0;
|
---|
500 | if (RT_C_IS_BLANK(pchLine[0]))
|
---|
501 | offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
|
---|
502 |
|
---|
503 | if (pchLine[offLine] != '*')
|
---|
504 | return false;
|
---|
505 | offLine++;
|
---|
506 |
|
---|
507 | if (!RT_C_IS_BLANK(pchLine[offLine + 1]))
|
---|
508 | return false;
|
---|
509 | offLine++;
|
---|
510 |
|
---|
511 | while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
|
---|
512 | offLine++;
|
---|
513 | if (offLine >= cchLine)
|
---|
514 | return false;
|
---|
515 | if (!RT_C_IS_UPPER(pchLine[offLine]))
|
---|
516 | return false;
|
---|
517 |
|
---|
518 | *ppchText = &pchLine[offLine];
|
---|
519 | size_t const offText = offLine;
|
---|
520 |
|
---|
521 | /* From the end now. */
|
---|
522 | offLine = cchLine - 1;
|
---|
523 | while (RT_C_IS_BLANK(pchLine[offLine]))
|
---|
524 | offLine--;
|
---|
525 |
|
---|
526 | if (pchLine[offLine] != '*')
|
---|
527 | return false;
|
---|
528 | offLine--;
|
---|
529 | if (!RT_C_IS_BLANK(pchLine[offLine]))
|
---|
530 | return false;
|
---|
531 | offLine--;
|
---|
532 | while (RT_C_IS_BLANK(pchLine[offLine]))
|
---|
533 | offLine--;
|
---|
534 | *pcchText = offLine - offText + 1;
|
---|
535 |
|
---|
536 | /*
|
---|
537 | * Third line closes the box.
|
---|
538 | */
|
---|
539 | pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol);
|
---|
540 | if (cchLine < cchBox - 3)
|
---|
541 | return false;
|
---|
542 |
|
---|
543 | offLine = 0;
|
---|
544 | if (RT_C_IS_BLANK(pchLine[0]))
|
---|
545 | offLine = RT_C_IS_BLANK(pchLine[1]) ? 2 : 1;
|
---|
546 | while (offLine < cchLine && pchLine[offLine] == '*')
|
---|
547 | offLine++;
|
---|
548 | if (offLine < cchBox - 4)
|
---|
549 | return false;
|
---|
550 |
|
---|
551 | if (pchLine[offLine] != '/')
|
---|
552 | return false;
|
---|
553 | offLine++;
|
---|
554 |
|
---|
555 | while (offLine < cchLine && RT_C_IS_BLANK(pchLine[offLine]))
|
---|
556 | offLine++;
|
---|
557 | if (offLine != cchLine)
|
---|
558 | return false;
|
---|
559 |
|
---|
560 | return true;
|
---|
561 | }
|
---|
562 |
|
---|
563 |
|
---|
564 | /**
|
---|
565 | * Flower box marker comments in C and C++ code.
|
---|
566 | *
|
---|
567 | * @returns true if modifications were made, false if not.
|
---|
568 | * @param pIn The input stream.
|
---|
569 | * @param pOut The output stream.
|
---|
570 | * @param pSettings The settings.
|
---|
571 | */
|
---|
572 | bool rewrite_FixFlowerBoxMarkers(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
573 | {
|
---|
574 | if (!pSettings->fFixFlowerBoxMarkers)
|
---|
575 | return false;
|
---|
576 |
|
---|
577 | /*
|
---|
578 | * Work thru the file line by line looking for flower box markers.
|
---|
579 | */
|
---|
580 | size_t cChanges = 0;
|
---|
581 | size_t cBlankLines = 0;
|
---|
582 | SCMEOL enmEol;
|
---|
583 | size_t cchLine;
|
---|
584 | const char *pchLine;
|
---|
585 | while ((pchLine = ScmStreamGetLine(pIn, &cchLine, &enmEol)) != NULL)
|
---|
586 | {
|
---|
587 | /*
|
---|
588 | * Get a likely match for a first line.
|
---|
589 | */
|
---|
590 | if ( pchLine[0] == '/'
|
---|
591 | && cchLine > 20
|
---|
592 | && pchLine[1] == '*'
|
---|
593 | && pchLine[2] == '*'
|
---|
594 | && pchLine[3] == '*')
|
---|
595 | {
|
---|
596 | size_t const offSaved = ScmStreamTell(pIn);
|
---|
597 | char const *pchText;
|
---|
598 | size_t cchText;
|
---|
599 | if (isFlowerBoxSectionMarker(pIn, pchLine, cchLine, &pchText, &cchText))
|
---|
600 | {
|
---|
601 | while (cBlankLines < pSettings->cMinBlankLinesBeforeFlowerBoxMakers)
|
---|
602 | {
|
---|
603 | ScmStreamPutEol(pOut, enmEol);
|
---|
604 | cBlankLines++;
|
---|
605 | }
|
---|
606 |
|
---|
607 | ScmStreamPutCh(pOut, '/');
|
---|
608 | ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
|
---|
609 | ScmStreamPutEol(pOut, enmEol);
|
---|
610 |
|
---|
611 | static const char s_szLead[] = "* ";
|
---|
612 | ScmStreamWrite(pOut, s_szLead, sizeof(s_szLead) - 1);
|
---|
613 | ScmStreamWrite(pOut, pchText, cchText);
|
---|
614 | size_t offCurPlus1 = sizeof(s_szLead) - 1 + cchText + 1;
|
---|
615 | ScmStreamWrite(pOut, g_szSpaces, offCurPlus1 < pSettings->cchWidth ? pSettings->cchWidth - offCurPlus1 : 1);
|
---|
616 | ScmStreamPutCh(pOut, '*');
|
---|
617 | ScmStreamPutEol(pOut, enmEol);
|
---|
618 |
|
---|
619 | ScmStreamWrite(pOut, g_szAsterisks, pSettings->cchWidth - 1);
|
---|
620 | ScmStreamPutCh(pOut, '/');
|
---|
621 | ScmStreamPutEol(pOut, enmEol);
|
---|
622 |
|
---|
623 | cChanges++;
|
---|
624 | cBlankLines = 0;
|
---|
625 | continue;
|
---|
626 | }
|
---|
627 |
|
---|
628 | int rc = ScmStreamSeekAbsolute(pIn, offSaved);
|
---|
629 | if (RT_FAILURE(rc))
|
---|
630 | return false;
|
---|
631 | }
|
---|
632 |
|
---|
633 | int rc = ScmStreamPutLine(pOut, pchLine, cchLine, enmEol);
|
---|
634 | if (RT_FAILURE(rc))
|
---|
635 | return false;
|
---|
636 |
|
---|
637 | /* Do blank line accounting so we can ensure at least two blank lines
|
---|
638 | before each section marker. */
|
---|
639 | if (!isBlankLine(pchLine, cchLine))
|
---|
640 | cBlankLines = 0;
|
---|
641 | else
|
---|
642 | cBlankLines++;
|
---|
643 | }
|
---|
644 | if (cChanges > 0)
|
---|
645 | ScmVerbose(pState, 2, " * Converted %zu flower boxer markers\n", cChanges);
|
---|
646 | return cChanges != 0;
|
---|
647 | }
|
---|
648 |
|
---|
649 | /**
|
---|
650 | * Rewrite a C/C++ source or header file.
|
---|
651 | *
|
---|
652 | * @returns true if modifications were made, false if not.
|
---|
653 | * @param pIn The input stream.
|
---|
654 | * @param pOut The output stream.
|
---|
655 | * @param pSettings The settings.
|
---|
656 | *
|
---|
657 | * @todo
|
---|
658 | *
|
---|
659 | * Ideas for C/C++:
|
---|
660 | * - space after if, while, for, switch
|
---|
661 | * - spaces in for (i=0;i<x;i++)
|
---|
662 | * - complex conditional, bird style.
|
---|
663 | * - remove unnecessary parentheses.
|
---|
664 | * - sort defined RT_OS_*|| and RT_ARCH
|
---|
665 | * - sizeof without parenthesis.
|
---|
666 | * - defined without parenthesis.
|
---|
667 | * - trailing spaces.
|
---|
668 | * - parameter indentation.
|
---|
669 | * - space after comma.
|
---|
670 | * - while (x--); -> multi line + comment.
|
---|
671 | * - else statement;
|
---|
672 | * - space between function and left parenthesis.
|
---|
673 | * - TODO, XXX, @todo cleanup.
|
---|
674 | * - Space before/after '*'.
|
---|
675 | * - ensure new line at end of file.
|
---|
676 | * - Indentation of precompiler statements (#ifdef, #defines).
|
---|
677 | * - space between functions.
|
---|
678 | * - string.h -> iprt/string.h, stdarg.h -> iprt/stdarg.h, etc.
|
---|
679 | */
|
---|
680 | bool rewrite_C_and_CPP(PSCMRWSTATE pState, PSCMSTREAM pIn, PSCMSTREAM pOut, PCSCMSETTINGSBASE pSettings)
|
---|
681 | {
|
---|
682 |
|
---|
683 | return false;
|
---|
684 | }
|
---|
685 |
|
---|