French translation: copy -> copie.
[git/dscho.git] / ws.c
blobb498d7599d5ac09c2688ee829b29aa36a866ac9c
1 /*
2 * Whitespace rules
4 * Copyright (c) 2007 Junio C Hamano
5 */
7 #include "cache.h"
8 #include "attr.h"
10 static struct whitespace_rule {
11 const char *rule_name;
12 unsigned rule_bits;
13 unsigned loosens_error:1,
14 exclude_default:1;
15 } whitespace_rule_names[] = {
16 { "trailing-space", WS_TRAILING_SPACE, 0 },
17 { "space-before-tab", WS_SPACE_BEFORE_TAB, 0 },
18 { "indent-with-non-tab", WS_INDENT_WITH_NON_TAB, 0 },
19 { "cr-at-eol", WS_CR_AT_EOL, 1 },
20 { "blank-at-eol", WS_BLANK_AT_EOL, 0 },
21 { "blank-at-eof", WS_BLANK_AT_EOF, 0 },
22 { "tab-in-indent", WS_TAB_IN_INDENT, 0, 1 },
25 unsigned parse_whitespace_rule(const char *string)
27 unsigned rule = WS_DEFAULT_RULE;
29 while (string) {
30 int i;
31 size_t len;
32 const char *ep;
33 int negated = 0;
35 string = string + strspn(string, ", \t\n\r");
36 ep = strchr(string, ',');
37 if (!ep)
38 len = strlen(string);
39 else
40 len = ep - string;
42 if (*string == '-') {
43 negated = 1;
44 string++;
45 len--;
47 if (!len)
48 break;
49 for (i = 0; i < ARRAY_SIZE(whitespace_rule_names); i++) {
50 if (strncmp(whitespace_rule_names[i].rule_name,
51 string, len))
52 continue;
53 if (negated)
54 rule &= ~whitespace_rule_names[i].rule_bits;
55 else
56 rule |= whitespace_rule_names[i].rule_bits;
57 break;
59 if (strncmp(string, "tabwidth=", 9) == 0) {
60 unsigned tabwidth = atoi(string + 9);
61 if (0 < tabwidth && tabwidth < 0100) {
62 rule &= ~WS_TAB_WIDTH_MASK;
63 rule |= tabwidth;
65 else
66 warning("tabwidth %.*s out of range",
67 (int)(len - 9), string + 9);
69 string = ep;
72 if (rule & WS_TAB_IN_INDENT && rule & WS_INDENT_WITH_NON_TAB)
73 die("cannot enforce both tab-in-indent and indent-with-non-tab");
74 return rule;
77 static void setup_whitespace_attr_check(struct git_attr_check *check)
79 static struct git_attr *attr_whitespace;
81 if (!attr_whitespace)
82 attr_whitespace = git_attr("whitespace");
83 check[0].attr = attr_whitespace;
86 unsigned whitespace_rule(const char *pathname)
88 struct git_attr_check attr_whitespace_rule;
90 setup_whitespace_attr_check(&attr_whitespace_rule);
91 if (!git_check_attr(pathname, 1, &attr_whitespace_rule)) {
92 const char *value;
94 value = attr_whitespace_rule.value;
95 if (ATTR_TRUE(value)) {
96 /* true (whitespace) */
97 unsigned all_rule = ws_tab_width(whitespace_rule_cfg);
98 int i;
99 for (i = 0; i < ARRAY_SIZE(whitespace_rule_names); i++)
100 if (!whitespace_rule_names[i].loosens_error &&
101 !whitespace_rule_names[i].exclude_default)
102 all_rule |= whitespace_rule_names[i].rule_bits;
103 return all_rule;
104 } else if (ATTR_FALSE(value)) {
105 /* false (-whitespace) */
106 return ws_tab_width(whitespace_rule_cfg);
107 } else if (ATTR_UNSET(value)) {
108 /* reset to default (!whitespace) */
109 return whitespace_rule_cfg;
110 } else {
111 /* string */
112 return parse_whitespace_rule(value);
114 } else {
115 return whitespace_rule_cfg;
119 /* The returned string should be freed by the caller. */
120 char *whitespace_error_string(unsigned ws)
122 struct strbuf err = STRBUF_INIT;
123 if ((ws & WS_TRAILING_SPACE) == WS_TRAILING_SPACE)
124 strbuf_addstr(&err, "trailing whitespace");
125 else {
126 if (ws & WS_BLANK_AT_EOL)
127 strbuf_addstr(&err, "trailing whitespace");
128 if (ws & WS_BLANK_AT_EOF) {
129 if (err.len)
130 strbuf_addstr(&err, ", ");
131 strbuf_addstr(&err, "new blank line at EOF");
134 if (ws & WS_SPACE_BEFORE_TAB) {
135 if (err.len)
136 strbuf_addstr(&err, ", ");
137 strbuf_addstr(&err, "space before tab in indent");
139 if (ws & WS_INDENT_WITH_NON_TAB) {
140 if (err.len)
141 strbuf_addstr(&err, ", ");
142 strbuf_addstr(&err, "indent with spaces");
144 if (ws & WS_TAB_IN_INDENT) {
145 if (err.len)
146 strbuf_addstr(&err, ", ");
147 strbuf_addstr(&err, "tab in indent");
149 return strbuf_detach(&err, NULL);
152 /* If stream is non-NULL, emits the line after checking. */
153 static unsigned ws_check_emit_1(const char *line, int len, unsigned ws_rule,
154 FILE *stream, const char *set,
155 const char *reset, const char *ws)
157 unsigned result = 0;
158 int written = 0;
159 int trailing_whitespace = -1;
160 int trailing_newline = 0;
161 int trailing_carriage_return = 0;
162 int i;
164 /* Logic is simpler if we temporarily ignore the trailing newline. */
165 if (len > 0 && line[len - 1] == '\n') {
166 trailing_newline = 1;
167 len--;
169 if ((ws_rule & WS_CR_AT_EOL) &&
170 len > 0 && line[len - 1] == '\r') {
171 trailing_carriage_return = 1;
172 len--;
175 /* Check for trailing whitespace. */
176 if (ws_rule & WS_BLANK_AT_EOL) {
177 for (i = len - 1; i >= 0; i--) {
178 if (isspace(line[i])) {
179 trailing_whitespace = i;
180 result |= WS_BLANK_AT_EOL;
182 else
183 break;
187 if (trailing_whitespace == -1)
188 trailing_whitespace = len;
190 /* Check indentation */
191 for (i = 0; i < trailing_whitespace; i++) {
192 if (line[i] == ' ')
193 continue;
194 if (line[i] != '\t')
195 break;
196 if ((ws_rule & WS_SPACE_BEFORE_TAB) && written < i) {
197 result |= WS_SPACE_BEFORE_TAB;
198 if (stream) {
199 fputs(ws, stream);
200 fwrite(line + written, i - written, 1, stream);
201 fputs(reset, stream);
202 fwrite(line + i, 1, 1, stream);
204 } else if (ws_rule & WS_TAB_IN_INDENT) {
205 result |= WS_TAB_IN_INDENT;
206 if (stream) {
207 fwrite(line + written, i - written, 1, stream);
208 fputs(ws, stream);
209 fwrite(line + i, 1, 1, stream);
210 fputs(reset, stream);
212 } else if (stream) {
213 fwrite(line + written, i - written + 1, 1, stream);
215 written = i + 1;
218 /* Check for indent using non-tab. */
219 if ((ws_rule & WS_INDENT_WITH_NON_TAB) && i - written >= ws_tab_width(ws_rule)) {
220 result |= WS_INDENT_WITH_NON_TAB;
221 if (stream) {
222 fputs(ws, stream);
223 fwrite(line + written, i - written, 1, stream);
224 fputs(reset, stream);
226 written = i;
229 if (stream) {
231 * Now the rest of the line starts at "written".
232 * The non-highlighted part ends at "trailing_whitespace".
235 /* Emit non-highlighted (middle) segment. */
236 if (trailing_whitespace - written > 0) {
237 fputs(set, stream);
238 fwrite(line + written,
239 trailing_whitespace - written, 1, stream);
240 fputs(reset, stream);
243 /* Highlight errors in trailing whitespace. */
244 if (trailing_whitespace != len) {
245 fputs(ws, stream);
246 fwrite(line + trailing_whitespace,
247 len - trailing_whitespace, 1, stream);
248 fputs(reset, stream);
250 if (trailing_carriage_return)
251 fputc('\r', stream);
252 if (trailing_newline)
253 fputc('\n', stream);
255 return result;
258 void ws_check_emit(const char *line, int len, unsigned ws_rule,
259 FILE *stream, const char *set,
260 const char *reset, const char *ws)
262 (void)ws_check_emit_1(line, len, ws_rule, stream, set, reset, ws);
265 unsigned ws_check(const char *line, int len, unsigned ws_rule)
267 return ws_check_emit_1(line, len, ws_rule, NULL, NULL, NULL, NULL);
270 int ws_blank_line(const char *line, int len, unsigned ws_rule)
273 * We _might_ want to treat CR differently from other
274 * whitespace characters when ws_rule has WS_CR_AT_EOL, but
275 * for now we just use this stupid definition.
277 while (len-- > 0) {
278 if (!isspace(*line))
279 return 0;
280 line++;
282 return 1;
285 /* Copy the line onto the end of the strbuf while fixing whitespaces */
286 void ws_fix_copy(struct strbuf *dst, const char *src, int len, unsigned ws_rule, int *error_count)
289 * len is number of bytes to be copied from src, starting
290 * at src. Typically src[len-1] is '\n', unless this is
291 * the incomplete last line.
293 int i;
294 int add_nl_to_tail = 0;
295 int add_cr_to_tail = 0;
296 int fixed = 0;
297 int last_tab_in_indent = -1;
298 int last_space_in_indent = -1;
299 int need_fix_leading_space = 0;
302 * Strip trailing whitespace
304 if (ws_rule & WS_BLANK_AT_EOL) {
305 if (0 < len && src[len - 1] == '\n') {
306 add_nl_to_tail = 1;
307 len--;
308 if (0 < len && src[len - 1] == '\r') {
309 add_cr_to_tail = !!(ws_rule & WS_CR_AT_EOL);
310 len--;
313 if (0 < len && isspace(src[len - 1])) {
314 while (0 < len && isspace(src[len-1]))
315 len--;
316 fixed = 1;
321 * Check leading whitespaces (indent)
323 for (i = 0; i < len; i++) {
324 char ch = src[i];
325 if (ch == '\t') {
326 last_tab_in_indent = i;
327 if ((ws_rule & WS_SPACE_BEFORE_TAB) &&
328 0 <= last_space_in_indent)
329 need_fix_leading_space = 1;
330 } else if (ch == ' ') {
331 last_space_in_indent = i;
332 if ((ws_rule & WS_INDENT_WITH_NON_TAB) &&
333 ws_tab_width(ws_rule) <= i - last_tab_in_indent)
334 need_fix_leading_space = 1;
335 } else
336 break;
339 if (need_fix_leading_space) {
340 /* Process indent ourselves */
341 int consecutive_spaces = 0;
342 int last = last_tab_in_indent + 1;
344 if (ws_rule & WS_INDENT_WITH_NON_TAB) {
345 /* have "last" point at one past the indent */
346 if (last_tab_in_indent < last_space_in_indent)
347 last = last_space_in_indent + 1;
348 else
349 last = last_tab_in_indent + 1;
353 * between src[0..last-1], strip the funny spaces,
354 * updating them to tab as needed.
356 for (i = 0; i < last; i++) {
357 char ch = src[i];
358 if (ch != ' ') {
359 consecutive_spaces = 0;
360 strbuf_addch(dst, ch);
361 } else {
362 consecutive_spaces++;
363 if (consecutive_spaces == ws_tab_width(ws_rule)) {
364 strbuf_addch(dst, '\t');
365 consecutive_spaces = 0;
369 while (0 < consecutive_spaces--)
370 strbuf_addch(dst, ' ');
371 len -= last;
372 src += last;
373 fixed = 1;
374 } else if ((ws_rule & WS_TAB_IN_INDENT) && last_tab_in_indent >= 0) {
375 /* Expand tabs into spaces */
376 int start = dst->len;
377 int last = last_tab_in_indent + 1;
378 for (i = 0; i < last; i++) {
379 if (src[i] == '\t')
380 do {
381 strbuf_addch(dst, ' ');
382 } while ((dst->len - start) % ws_tab_width(ws_rule));
383 else
384 strbuf_addch(dst, src[i]);
386 len -= last;
387 src += last;
388 fixed = 1;
391 strbuf_add(dst, src, len);
392 if (add_cr_to_tail)
393 strbuf_addch(dst, '\r');
394 if (add_nl_to_tail)
395 strbuf_addch(dst, '\n');
396 if (fixed && error_count)
397 (*error_count)++;