4 * Copyright (c) 2007 Junio C Hamano
9 static struct whitespace_rule
{
10 const char *rule_name
;
12 unsigned loosens_error
:1,
14 } whitespace_rule_names
[] = {
15 { "trailing-space", WS_TRAILING_SPACE
, 0 },
16 { "space-before-tab", WS_SPACE_BEFORE_TAB
, 0 },
17 { "indent-with-non-tab", WS_INDENT_WITH_NON_TAB
, 0 },
18 { "cr-at-eol", WS_CR_AT_EOL
, 1 },
19 { "blank-at-eol", WS_BLANK_AT_EOL
, 0 },
20 { "blank-at-eof", WS_BLANK_AT_EOF
, 0 },
21 { "tab-in-indent", WS_TAB_IN_INDENT
, 0, 1 },
24 unsigned parse_whitespace_rule(const char *string
)
26 unsigned rule
= WS_DEFAULT_RULE
;
34 string
= string
+ strspn(string
, ", \t\n\r");
35 ep
= strchrnul(string
, ',');
45 for (i
= 0; i
< ARRAY_SIZE(whitespace_rule_names
); i
++) {
46 if (strncmp(whitespace_rule_names
[i
].rule_name
,
50 rule
&= ~whitespace_rule_names
[i
].rule_bits
;
52 rule
|= whitespace_rule_names
[i
].rule_bits
;
55 if (strncmp(string
, "tabwidth=", 9) == 0) {
56 unsigned tabwidth
= atoi(string
+ 9);
57 if (0 < tabwidth
&& tabwidth
< 0100) {
58 rule
&= ~WS_TAB_WIDTH_MASK
;
62 warning("tabwidth %.*s out of range",
63 (int)(len
- 9), string
+ 9);
68 if (rule
& WS_TAB_IN_INDENT
&& rule
& WS_INDENT_WITH_NON_TAB
)
69 die("cannot enforce both tab-in-indent and indent-with-non-tab");
73 unsigned whitespace_rule(struct index_state
*istate
, const char *pathname
)
75 static struct attr_check
*attr_whitespace_rule
;
77 if (!attr_whitespace_rule
)
78 attr_whitespace_rule
= attr_check_initl("whitespace", NULL
);
80 if (!git_check_attr(istate
, pathname
, attr_whitespace_rule
)) {
83 value
= attr_whitespace_rule
->items
[0].value
;
84 if (ATTR_TRUE(value
)) {
85 /* true (whitespace) */
86 unsigned all_rule
= ws_tab_width(whitespace_rule_cfg
);
88 for (i
= 0; i
< ARRAY_SIZE(whitespace_rule_names
); i
++)
89 if (!whitespace_rule_names
[i
].loosens_error
&&
90 !whitespace_rule_names
[i
].exclude_default
)
91 all_rule
|= whitespace_rule_names
[i
].rule_bits
;
93 } else if (ATTR_FALSE(value
)) {
94 /* false (-whitespace) */
95 return ws_tab_width(whitespace_rule_cfg
);
96 } else if (ATTR_UNSET(value
)) {
97 /* reset to default (!whitespace) */
98 return whitespace_rule_cfg
;
101 return parse_whitespace_rule(value
);
104 return whitespace_rule_cfg
;
108 /* The returned string should be freed by the caller. */
109 char *whitespace_error_string(unsigned ws
)
111 struct strbuf err
= STRBUF_INIT
;
112 if ((ws
& WS_TRAILING_SPACE
) == WS_TRAILING_SPACE
)
113 strbuf_addstr(&err
, "trailing whitespace");
115 if (ws
& WS_BLANK_AT_EOL
)
116 strbuf_addstr(&err
, "trailing whitespace");
117 if (ws
& WS_BLANK_AT_EOF
) {
119 strbuf_addstr(&err
, ", ");
120 strbuf_addstr(&err
, "new blank line at EOF");
123 if (ws
& WS_SPACE_BEFORE_TAB
) {
125 strbuf_addstr(&err
, ", ");
126 strbuf_addstr(&err
, "space before tab in indent");
128 if (ws
& WS_INDENT_WITH_NON_TAB
) {
130 strbuf_addstr(&err
, ", ");
131 strbuf_addstr(&err
, "indent with spaces");
133 if (ws
& WS_TAB_IN_INDENT
) {
135 strbuf_addstr(&err
, ", ");
136 strbuf_addstr(&err
, "tab in indent");
138 return strbuf_detach(&err
, NULL
);
141 /* If stream is non-NULL, emits the line after checking. */
142 static unsigned ws_check_emit_1(const char *line
, int len
, unsigned ws_rule
,
143 FILE *stream
, const char *set
,
144 const char *reset
, const char *ws
)
148 int trailing_whitespace
= -1;
149 int trailing_newline
= 0;
150 int trailing_carriage_return
= 0;
153 /* Logic is simpler if we temporarily ignore the trailing newline. */
154 if (len
> 0 && line
[len
- 1] == '\n') {
155 trailing_newline
= 1;
158 if ((ws_rule
& WS_CR_AT_EOL
) &&
159 len
> 0 && line
[len
- 1] == '\r') {
160 trailing_carriage_return
= 1;
164 /* Check for trailing whitespace. */
165 if (ws_rule
& WS_BLANK_AT_EOL
) {
166 for (i
= len
- 1; i
>= 0; i
--) {
167 if (isspace(line
[i
])) {
168 trailing_whitespace
= i
;
169 result
|= WS_BLANK_AT_EOL
;
176 if (trailing_whitespace
== -1)
177 trailing_whitespace
= len
;
179 /* Check indentation */
180 for (i
= 0; i
< trailing_whitespace
; i
++) {
185 if ((ws_rule
& WS_SPACE_BEFORE_TAB
) && written
< i
) {
186 result
|= WS_SPACE_BEFORE_TAB
;
189 fwrite(line
+ written
, i
- written
, 1, stream
);
190 fputs(reset
, stream
);
191 fwrite(line
+ i
, 1, 1, stream
);
193 } else if (ws_rule
& WS_TAB_IN_INDENT
) {
194 result
|= WS_TAB_IN_INDENT
;
196 fwrite(line
+ written
, i
- written
, 1, stream
);
198 fwrite(line
+ i
, 1, 1, stream
);
199 fputs(reset
, stream
);
202 fwrite(line
+ written
, i
- written
+ 1, 1, stream
);
207 /* Check for indent using non-tab. */
208 if ((ws_rule
& WS_INDENT_WITH_NON_TAB
) && i
- written
>= ws_tab_width(ws_rule
)) {
209 result
|= WS_INDENT_WITH_NON_TAB
;
212 fwrite(line
+ written
, i
- written
, 1, stream
);
213 fputs(reset
, stream
);
220 * Now the rest of the line starts at "written".
221 * The non-highlighted part ends at "trailing_whitespace".
224 /* Emit non-highlighted (middle) segment. */
225 if (trailing_whitespace
- written
> 0) {
227 fwrite(line
+ written
,
228 trailing_whitespace
- written
, 1, stream
);
229 fputs(reset
, stream
);
232 /* Highlight errors in trailing whitespace. */
233 if (trailing_whitespace
!= len
) {
235 fwrite(line
+ trailing_whitespace
,
236 len
- trailing_whitespace
, 1, stream
);
237 fputs(reset
, stream
);
239 if (trailing_carriage_return
)
241 if (trailing_newline
)
247 void ws_check_emit(const char *line
, int len
, unsigned ws_rule
,
248 FILE *stream
, const char *set
,
249 const char *reset
, const char *ws
)
251 (void)ws_check_emit_1(line
, len
, ws_rule
, stream
, set
, reset
, ws
);
254 unsigned ws_check(const char *line
, int len
, unsigned ws_rule
)
256 return ws_check_emit_1(line
, len
, ws_rule
, NULL
, NULL
, NULL
, NULL
);
259 int ws_blank_line(const char *line
, int len
, unsigned ws_rule
)
262 * We _might_ want to treat CR differently from other
263 * whitespace characters when ws_rule has WS_CR_AT_EOL, but
264 * for now we just use this stupid definition.
274 /* Copy the line onto the end of the strbuf while fixing whitespaces */
275 void ws_fix_copy(struct strbuf
*dst
, const char *src
, int len
, unsigned ws_rule
, int *error_count
)
278 * len is number of bytes to be copied from src, starting
279 * at src. Typically src[len-1] is '\n', unless this is
280 * the incomplete last line.
283 int add_nl_to_tail
= 0;
284 int add_cr_to_tail
= 0;
286 int last_tab_in_indent
= -1;
287 int last_space_in_indent
= -1;
288 int need_fix_leading_space
= 0;
291 * Strip trailing whitespace
293 if (ws_rule
& WS_BLANK_AT_EOL
) {
294 if (0 < len
&& src
[len
- 1] == '\n') {
297 if (0 < len
&& src
[len
- 1] == '\r') {
298 add_cr_to_tail
= !!(ws_rule
& WS_CR_AT_EOL
);
302 if (0 < len
&& isspace(src
[len
- 1])) {
303 while (0 < len
&& isspace(src
[len
-1]))
310 * Check leading whitespaces (indent)
312 for (i
= 0; i
< len
; i
++) {
315 last_tab_in_indent
= i
;
316 if ((ws_rule
& WS_SPACE_BEFORE_TAB
) &&
317 0 <= last_space_in_indent
)
318 need_fix_leading_space
= 1;
319 } else if (ch
== ' ') {
320 last_space_in_indent
= i
;
321 if ((ws_rule
& WS_INDENT_WITH_NON_TAB
) &&
322 ws_tab_width(ws_rule
) <= i
- last_tab_in_indent
)
323 need_fix_leading_space
= 1;
328 if (need_fix_leading_space
) {
329 /* Process indent ourselves */
330 int consecutive_spaces
= 0;
331 int last
= last_tab_in_indent
+ 1;
333 if (ws_rule
& WS_INDENT_WITH_NON_TAB
) {
334 /* have "last" point at one past the indent */
335 if (last_tab_in_indent
< last_space_in_indent
)
336 last
= last_space_in_indent
+ 1;
338 last
= last_tab_in_indent
+ 1;
342 * between src[0..last-1], strip the funny spaces,
343 * updating them to tab as needed.
345 for (i
= 0; i
< last
; i
++) {
348 consecutive_spaces
= 0;
349 strbuf_addch(dst
, ch
);
351 consecutive_spaces
++;
352 if (consecutive_spaces
== ws_tab_width(ws_rule
)) {
353 strbuf_addch(dst
, '\t');
354 consecutive_spaces
= 0;
358 while (0 < consecutive_spaces
--)
359 strbuf_addch(dst
, ' ');
363 } else if ((ws_rule
& WS_TAB_IN_INDENT
) && last_tab_in_indent
>= 0) {
364 /* Expand tabs into spaces */
365 int start
= dst
->len
;
366 int last
= last_tab_in_indent
+ 1;
367 for (i
= 0; i
< last
; i
++) {
370 strbuf_addch(dst
, ' ');
371 } while ((dst
->len
- start
) % ws_tab_width(ws_rule
));
373 strbuf_addch(dst
, src
[i
]);
380 strbuf_add(dst
, src
, len
);
382 strbuf_addch(dst
, '\r');
384 strbuf_addch(dst
, '\n');
385 if (fixed
&& error_count
)