Mercurial > hg
comparison mercurial/mpatch.c @ 41336:763b45bc4483
cleanup: use clang-tidy to add missing {} around one-line statements
I find this easier to read. Cleanup performed like this:
hg files 'set:(**.c or **.cc or **.h) and not "listfile:contrib/clang-format-ignorelist"' | while read f ; do
clang-tidy -fix -checks=readability-braces-around-statements $f -- $(python-config --cflags) -Imercurial/cext -Imercurial
done
make format-c
I had to revert chg/chg.c as it's got a construct that seems to confuse
clang-tidy, so I'll work on that file later if this change is acceptable. I
only tackle files that are under clang-format's authority because otherwise
I'd have to do a bunch of manual formatting. A few files didn't get edited
because clang-tidy couldn't find some headers. Again, I'll figure that out
later assuming this change is accepted.
No check-code rule added for now because writing the regex sounds hard. In a
perfect world I guess we could write a test that uses clang-tidy on these
files, but I think clang-tidy is pretty rarely installed. :/
Differential Revision: https://phab.mercurial-scm.org/D5675
author | Augie Fackler <augie@google.com> |
---|---|
date | Thu, 24 Jan 2019 10:21:59 -0500 |
parents | 9c5ced5276d6 |
children | d4ba4d51f85f |
comparison
equal
deleted
inserted
replaced
41335:b81ca9a3f4e4 | 41336:763b45bc4483 |
---|---|
39 | 39 |
40 static struct mpatch_flist *lalloc(ssize_t size) | 40 static struct mpatch_flist *lalloc(ssize_t size) |
41 { | 41 { |
42 struct mpatch_flist *a = NULL; | 42 struct mpatch_flist *a = NULL; |
43 | 43 |
44 if (size < 1) | 44 if (size < 1) { |
45 size = 1; | 45 size = 1; |
46 } | |
46 | 47 |
47 a = (struct mpatch_flist *)malloc(sizeof(struct mpatch_flist)); | 48 a = (struct mpatch_flist *)malloc(sizeof(struct mpatch_flist)); |
48 if (a) { | 49 if (a) { |
49 a->base = (struct mpatch_frag *)malloc( | 50 a->base = (struct mpatch_frag *)malloc( |
50 sizeof(struct mpatch_frag) * size); | 51 sizeof(struct mpatch_frag) * size); |
108 struct mpatch_frag *d = dest->tail, *s = src->head; | 109 struct mpatch_frag *d = dest->tail, *s = src->head; |
109 int postend, c, l; | 110 int postend, c, l; |
110 | 111 |
111 while (s != src->tail) { | 112 while (s != src->tail) { |
112 int soffset = s->start; | 113 int soffset = s->start; |
113 if (!safeadd(offset, &soffset)) | 114 if (!safeadd(offset, &soffset)) { |
114 break; /* add would overflow, oh well */ | 115 break; /* add would overflow, oh well */ |
115 if (soffset >= cut) | 116 } |
117 if (soffset >= cut) { | |
116 break; /* we've gone far enough */ | 118 break; /* we've gone far enough */ |
119 } | |
117 | 120 |
118 postend = offset; | 121 postend = offset; |
119 if (!safeadd(s->start, &postend) || | 122 if (!safeadd(s->start, &postend) || |
120 !safeadd(s->len, &postend)) { | 123 !safeadd(s->len, &postend)) { |
121 break; | 124 break; |
137 /* break up this hunk */ | 140 /* break up this hunk */ |
138 c = cut; | 141 c = cut; |
139 if (!safesub(offset, &c)) { | 142 if (!safesub(offset, &c)) { |
140 break; | 143 break; |
141 } | 144 } |
142 if (s->end < c) | 145 if (s->end < c) { |
143 c = s->end; | 146 c = s->end; |
147 } | |
144 l = cut - offset - s->start; | 148 l = cut - offset - s->start; |
145 if (s->len < l) | 149 if (s->len < l) { |
146 l = s->len; | 150 l = s->len; |
151 } | |
147 | 152 |
148 offset += s->start + l - c; | 153 offset += s->start + l - c; |
149 | 154 |
150 d->start = s->start; | 155 d->start = s->start; |
151 d->end = c; | 156 d->end = c; |
174 while (s != src->tail) { | 179 while (s != src->tail) { |
175 int cmpcut = s->start; | 180 int cmpcut = s->start; |
176 if (!safeadd(offset, &cmpcut)) { | 181 if (!safeadd(offset, &cmpcut)) { |
177 break; | 182 break; |
178 } | 183 } |
179 if (cmpcut >= cut) | 184 if (cmpcut >= cut) { |
180 break; | 185 break; |
186 } | |
181 | 187 |
182 postend = offset; | 188 postend = offset; |
183 if (!safeadd(s->start, &postend)) { | 189 if (!safeadd(s->start, &postend)) { |
184 break; | 190 break; |
185 } | 191 } |
203 } else { | 209 } else { |
204 c = cut; | 210 c = cut; |
205 if (!safesub(offset, &c)) { | 211 if (!safesub(offset, &c)) { |
206 break; | 212 break; |
207 } | 213 } |
208 if (s->end < c) | 214 if (s->end < c) { |
209 c = s->end; | 215 c = s->end; |
216 } | |
210 l = cut - offset - s->start; | 217 l = cut - offset - s->start; |
211 if (s->len < l) | 218 if (s->len < l) { |
212 l = s->len; | 219 l = s->len; |
220 } | |
213 | 221 |
214 offset += s->start + l - c; | 222 offset += s->start + l - c; |
215 s->start = c; | 223 s->start = c; |
216 s->len = s->len - l; | 224 s->len = s->len - l; |
217 s->data = s->data + l; | 225 s->data = s->data + l; |
231 { | 239 { |
232 struct mpatch_flist *c = NULL; | 240 struct mpatch_flist *c = NULL; |
233 struct mpatch_frag *bh, *ct; | 241 struct mpatch_frag *bh, *ct; |
234 int offset = 0, post; | 242 int offset = 0, post; |
235 | 243 |
236 if (a && b) | 244 if (a && b) { |
237 c = lalloc((lsize(a) + lsize(b)) * 2); | 245 c = lalloc((lsize(a) + lsize(b)) * 2); |
246 } | |
238 | 247 |
239 if (c) { | 248 if (c) { |
240 | 249 |
241 for (bh = b->head; bh != b->tail; bh++) { | 250 for (bh = b->head; bh != b->tail; bh++) { |
242 /* save old hunks */ | 251 /* save old hunks */ |
282 struct mpatch_frag *lt; | 291 struct mpatch_frag *lt; |
283 int pos = 0; | 292 int pos = 0; |
284 | 293 |
285 /* assume worst case size, we won't have many of these lists */ | 294 /* assume worst case size, we won't have many of these lists */ |
286 l = lalloc(len / 12 + 1); | 295 l = lalloc(len / 12 + 1); |
287 if (!l) | 296 if (!l) { |
288 return MPATCH_ERR_NO_MEM; | 297 return MPATCH_ERR_NO_MEM; |
298 } | |
289 | 299 |
290 lt = l->tail; | 300 lt = l->tail; |
291 | 301 |
292 /* We check against len-11 to ensure we have at least 12 bytes | 302 /* We check against len-11 to ensure we have at least 12 bytes |
293 left in the patch so we can read our three be32s out of it. */ | 303 left in the patch so we can read our three be32s out of it. */ |
294 while (pos >= 0 && pos < (len - 11)) { | 304 while (pos >= 0 && pos < (len - 11)) { |
295 lt->start = getbe32(bin + pos); | 305 lt->start = getbe32(bin + pos); |
296 lt->end = getbe32(bin + pos + 4); | 306 lt->end = getbe32(bin + pos + 4); |
297 lt->len = getbe32(bin + pos + 8); | 307 lt->len = getbe32(bin + pos + 8); |
298 if (lt->start < 0 || lt->start > lt->end || lt->len < 0) | 308 if (lt->start < 0 || lt->start > lt->end || lt->len < 0) { |
299 break; /* sanity check */ | 309 break; /* sanity check */ |
310 } | |
300 if (!safeadd(12, &pos)) { | 311 if (!safeadd(12, &pos)) { |
301 break; | 312 break; |
302 } | 313 } |
303 lt->data = bin + pos; | 314 lt->data = bin + pos; |
304 if (!safeadd(lt->len, &pos)) { | 315 if (!safeadd(lt->len, &pos)) { |