1/*
2 * Whitespace rules
3 *
4 * Copyright (c) 2007 Junio C Hamano
5 */
6#include "cache.h"
8#include "attr.h"
9static struct whitespace_rule {
11 const char *rule_name;
12 unsigned rule_bits;
13} whitespace_rule_names[] = {
14 { "trailing-space", WS_TRAILING_SPACE },
15 { "space-before-tab", WS_SPACE_BEFORE_TAB },
16 { "indent-with-non-tab", WS_INDENT_WITH_NON_TAB },
17 { "cr-at-eol", WS_CR_AT_EOL },
18};
19unsigned parse_whitespace_rule(const char *string)
21{
22 unsigned rule = WS_DEFAULT_RULE;
23 while (string) {
25 int i;
26 size_t len;
27 const char *ep;
28 int negated = 0;
29 string = string + strspn(string, ", \t\n\r");
31 ep = strchr(string, ',');
32 if (!ep)
33 len = strlen(string);
34 else
35 len = ep - string;
36 if (*string == '-') {
38 negated = 1;
39 string++;
40 len--;
41 }
42 if (!len)
43 break;
44 for (i = 0; i < ARRAY_SIZE(whitespace_rule_names); i++) {
45 if (strncmp(whitespace_rule_names[i].rule_name,
46 string, len))
47 continue;
48 if (negated)
49 rule &= ~whitespace_rule_names[i].rule_bits;
50 else
51 rule |= whitespace_rule_names[i].rule_bits;
52 break;
53 }
54 string = ep;
55 }
56 return rule;
57}
58static void setup_whitespace_attr_check(struct git_attr_check *check)
60{
61 static struct git_attr *attr_whitespace;
62 if (!attr_whitespace)
64 attr_whitespace = git_attr("whitespace", 10);
65 check[0].attr = attr_whitespace;
66}
67unsigned whitespace_rule(const char *pathname)
69{
70 struct git_attr_check attr_whitespace_rule;
71 setup_whitespace_attr_check(&attr_whitespace_rule);
73 if (!git_checkattr(pathname, 1, &attr_whitespace_rule)) {
74 const char *value;
75 value = attr_whitespace_rule.value;
77 if (ATTR_TRUE(value)) {
78 /* true (whitespace) */
79 unsigned all_rule = 0;
80 int i;
81 for (i = 0; i < ARRAY_SIZE(whitespace_rule_names); i++)
82 all_rule |= whitespace_rule_names[i].rule_bits;
83 return all_rule;
84 } else if (ATTR_FALSE(value)) {
85 /* false (-whitespace) */
86 return 0;
87 } else if (ATTR_UNSET(value)) {
88 /* reset to default (!whitespace) */
89 return whitespace_rule_cfg;
90 } else {
91 /* string */
92 return parse_whitespace_rule(value);
93 }
94 } else {
95 return whitespace_rule_cfg;
96 }
97}
98/* The returned string should be freed by the caller. */
100char *whitespace_error_string(unsigned ws)
101{
102 struct strbuf err;
103 strbuf_init(&err, 0);
104 if (ws & WS_TRAILING_SPACE)
105 strbuf_addstr(&err, "trailing whitespace");
106 if (ws & WS_SPACE_BEFORE_TAB) {
107 if (err.len)
108 strbuf_addstr(&err, ", ");
109 strbuf_addstr(&err, "space before tab in indent");
110 }
111 if (ws & WS_INDENT_WITH_NON_TAB) {
112 if (err.len)
113 strbuf_addstr(&err, ", ");
114 strbuf_addstr(&err, "indent with spaces");
115 }
116 return strbuf_detach(&err, NULL);
117}
118/* If stream is non-NULL, emits the line after checking. */
120unsigned check_and_emit_line(const char *line, int len, unsigned ws_rule,
121 FILE *stream, const char *set,
122 const char *reset, const char *ws)
123{
124 unsigned result = 0;
125 int written = 0;
126 int trailing_whitespace = -1;
127 int trailing_newline = 0;
128 int trailing_carriage_return = 0;
129 int i;
130 /* Logic is simpler if we temporarily ignore the trailing newline. */
132 if (len > 0 && line[len - 1] == '\n') {
133 trailing_newline = 1;
134 len--;
135 }
136 if ((ws_rule & WS_CR_AT_EOL) &&
137 len > 0 && line[len - 1] == '\r') {
138 trailing_carriage_return = 1;
139 len--;
140 }
141 /* Check for trailing whitespace. */
143 if (ws_rule & WS_TRAILING_SPACE) {
144 for (i = len - 1; i >= 0; i--) {
145 if (isspace(line[i])) {
146 trailing_whitespace = i;
147 result |= WS_TRAILING_SPACE;
148 }
149 else
150 break;
151 }
152 }
153 /* Check for space before tab in initial indent. */
155 for (i = 0; i < len; i++) {
156 if (line[i] == ' ')
157 continue;
158 if (line[i] != '\t')
159 break;
160 if ((ws_rule & WS_SPACE_BEFORE_TAB) && written < i) {
161 result |= WS_SPACE_BEFORE_TAB;
162 if (stream) {
163 fputs(ws, stream);
164 fwrite(line + written, i - written, 1, stream);
165 fputs(reset, stream);
166 }
167 } else if (stream)
168 fwrite(line + written, i - written, 1, stream);
169 if (stream)
170 fwrite(line + i, 1, 1, stream);
171 written = i + 1;
172 }
173 /* Check for indent using non-tab. */
175 if ((ws_rule & WS_INDENT_WITH_NON_TAB) && i - written >= 8) {
176 result |= WS_INDENT_WITH_NON_TAB;
177 if (stream) {
178 fputs(ws, stream);
179 fwrite(line + written, i - written, 1, stream);
180 fputs(reset, stream);
181 }
182 written = i;
183 }
184 if (stream) {
186 /*
187 * Now the rest of the line starts at "written".
188 * The non-highlighted part ends at "trailing_whitespace".
189 */
190 if (trailing_whitespace == -1)
191 trailing_whitespace = len;
192 /* Emit non-highlighted (middle) segment. */
194 if (trailing_whitespace - written > 0) {
195 fputs(set, stream);
196 fwrite(line + written,
197 trailing_whitespace - written, 1, stream);
198 fputs(reset, stream);
199 }
200 /* Highlight errors in trailing whitespace. */
202 if (trailing_whitespace != len) {
203 fputs(ws, stream);
204 fwrite(line + trailing_whitespace,
205 len - trailing_whitespace, 1, stream);
206 fputs(reset, stream);
207 }
208 if (trailing_carriage_return)
209 fputc('\r', stream);
210 if (trailing_newline)
211 fputc('\n', stream);
212 }
213 return result;
214}
215/* Copy the line to the buffer while fixing whitespaces */
217int ws_fix_copy(char *dst, const char *src, int len, unsigned ws_rule, int *error_count)
218{
219 /*
220 * len is number of bytes to be copied from src, starting
221 * at src. Typically src[len-1] is '\n', unless this is
222 * the incomplete last line.
223 */
224 int i;
225 int add_nl_to_tail = 0;
226 int add_cr_to_tail = 0;
227 int fixed = 0;
228 int last_tab_in_indent = -1;
229 int last_space_in_indent = -1;
230 int need_fix_leading_space = 0;
231 char *buf;
232 /*
234 * Strip trailing whitespace
235 */
236 if ((ws_rule & WS_TRAILING_SPACE) &&
237 (2 <= len && isspace(src[len-2]))) {
238 if (src[len - 1] == '\n') {
239 add_nl_to_tail = 1;
240 len--;
241 if (1 < len && src[len - 1] == '\r') {
242 add_cr_to_tail = !!(ws_rule & WS_CR_AT_EOL);
243 len--;
244 }
245 }
246 if (0 < len && isspace(src[len - 1])) {
247 while (0 < len && isspace(src[len-1]))
248 len--;
249 fixed = 1;
250 }
251 }
252 /*
254 * Check leading whitespaces (indent)
255 */
256 for (i = 0; i < len; i++) {
257 char ch = src[i];
258 if (ch == '\t') {
259 last_tab_in_indent = i;
260 if ((ws_rule & WS_SPACE_BEFORE_TAB) &&
261 0 <= last_space_in_indent)
262 need_fix_leading_space = 1;
263 } else if (ch == ' ') {
264 last_space_in_indent = i;
265 if ((ws_rule & WS_INDENT_WITH_NON_TAB) &&
266 8 <= i - last_tab_in_indent)
267 need_fix_leading_space = 1;
268 } else
269 break;
270 }
271 buf = dst;
273 if (need_fix_leading_space) {
274 /* Process indent ourselves */
275 int consecutive_spaces = 0;
276 int last = last_tab_in_indent + 1;
277 if (ws_rule & WS_INDENT_WITH_NON_TAB) {
279 /* have "last" point at one past the indent */
280 if (last_tab_in_indent < last_space_in_indent)
281 last = last_space_in_indent + 1;
282 else
283 last = last_tab_in_indent + 1;
284 }
285 /*
287 * between src[0..last-1], strip the funny spaces,
288 * updating them to tab as needed.
289 */
290 for (i = 0; i < last; i++) {
291 char ch = src[i];
292 if (ch != ' ') {
293 consecutive_spaces = 0;
294 *dst++ = ch;
295 } else {
296 consecutive_spaces++;
297 if (consecutive_spaces == 8) {
298 *dst++ = '\t';
299 consecutive_spaces = 0;
300 }
301 }
302 }
303 while (0 < consecutive_spaces--)
304 *dst++ = ' ';
305 len -= last;
306 src += last;
307 fixed = 1;
308 }
309 memcpy(dst, src, len);
311 if (add_cr_to_tail)
312 dst[len++] = '\r';
313 if (add_nl_to_tail)
314 dst[len++] = '\n';
315 if (fixed && error_count)
316 (*error_count)++;
317 return dst + len - buf;
318}