•  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
더 보기

사용자:Topoi/patch-7982fe078c2b4a25260c1bfdeb4f78df3b1e641225c3006bdd06dc78c766c2c9(r2 Blame)

r2
r1
Topoi
1{{{#!syntax diff
2diff --git a/builtin/commit.c b/builtin/commit.c
3index 2f45968222..25e26a2f70 100644
4--- a/builtin/commit.c
5+++ b/builtin/commit.c
6@@ -125,7 +125,7 @@ static int all, also, interactive, patch_interactive, only, amend, signoff;
7 static int edit_flag = -1; /* unspecified */
8 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
9 static int config_commit_verbose = -1; /* unspecified */
10-static int no_post_rewrite, allow_empty_message, pathspec_file_nul;
11+static int no_post_rewrite, allow_empty_message = 1, pathspec_file_nul;
12 static const char *untracked_files_arg, *force_date, *ignore_submodule_arg, *ignored_arg;
13 static const char *sign_commit, *pathspec_from_file;
14 static struct strvec trailer_args = STRVEC_INIT;
15}}}
16
r2
Topoi
17문제는 이대로 빌드하면 unit test가 실패하는 듯하다.
18
19{{{#!syntax sh
20error: builder for '/nix/store/m9iqhqfxxqs7p6jdj2jcf9aq2ygfiv0a-git-2.47.2.drv' failed with exit code 2;
21 last 25 log lines:
22 > t3404-rebase-interactive.sh (Wstat: 256 (exited 1) Tests: 131 Failed: 3)
23 > Failed tests: 42-44
24 > Non-zero exit status: 1
25 > t7500-commit-template-squash-signoff.sh (Wstat: 256 (exited 1) Tests: 54 Failed: 5)
26 > Failed tests: 4, 8, 22, 24, 34
27 > Non-zero exit status: 1
28 > t7501-commit-basic-functionality.sh (Wstat: 256 (exited 1) Tests: 77 Failed: 4)
29 > Failed tests: 27, 29, 39, 47
30 > Non-zero exit status: 1
31 > t7507-commit-verbose.sh (Wstat: 256 (exited 1) Tests: 45 Failed: 23)
32 > Failed tests: 8-10, 13-14, 19-21, 23-24, 26-27, 29-30
33 > 32-33, 35-36, 38-39, 41-42, 44
34 > Non-zero exit status: 1
35 > t7502-commit-porcelain.sh (Wstat: 256 (exited 1) Tests: 81 Failed: 1)
36 > Failed test: 39
37 > Non-zero exit status: 1
38 > t7508-status.sh (Wstat: 256 (exited 1) Tests: 125 Failed: 66)
39 > Failed tests: 13-19, 21-35, 37-41, 50-54, 58-66, 69, 71-93
40 > 107
41 > Non-zero exit status: 1
42 > Files=1023, Tests=30126, 216 wallclock secs (10.62 usr 2.79 sys + 449.92 cusr 960.70 csys = 1424.03 CPU)
43 > Result: FAIL
44 > make[1]: *** [Makefile:73: prove] Error 1
45 > make[1]: Leaving directory '/build/git-2.47.2/t'
46 > make: *** [Makefile:3273: test] Error 2
47 For full logs, run 'nix log /nix/store/m9iqhqfxxqs7p6jdj2jcf9aq2ygfiv0a-git-2.47.2.drv'.
48error: 1 dependencies of derivation '/nix/store/2i62rn1l27qy4gm30msn39i0ban9q5f1-git-2.47.2-fish-completions.drv' failed to build
49error: 1 dependencies of derivation '/nix/store/hx9d5rydwzi4inqhbfi33azafafv7071-home-manager-path.drv' failed to build
50error: 1 dependencies of derivation '/nix/store/whrrhjd3lwjv6kj6j7smd3xx1h3b1d3l-home-manager-generation.drv' failed to build}}}
51
r1
Topoi
52{{{#!syntax cpp
53struct delta_index {
54 unsigned long memsize;
55 const void *src_buf;
56 unsigned long src_size;
57 unsigned int hash_mask;
58 struct index_entry *hash[FLEX_ARRAY];
59};
60
61struct delta_index * create_delta_index(const void *buf, unsigned long bufsize)
62{
63 unsigned int i, hsize, hmask, entries, prev_val, *hash_count;
64 const unsigned char *data, *buffer = buf;
65 struct delta_index *index;
66 struct unpacked_index_entry *entry, **hash;
67 struct index_entry *packed_entry, **packed_hash;
68 void *mem;
69 unsigned long memsize;
70
71 if (!buf || !bufsize)
72 return NULL;
73
74 entries = (bufsize - 1) / RABIN_WINDOW;
75 if (bufsize >= 0xffffffffUL) {
76 entries = 0xfffffffeU / RABIN_WINDOW;
77 }
78 hsize = entries / 4;
79 for (i = 4; (1u << i) < hsize; i++);
80 hsize = 1 << i;
81 hmask = hsize - 1;
82
83 /* allocate lookup index */
84 memsize = sizeof(*hash) * hsize +
85 sizeof(*entry) * entries;
86 mem = malloc(memsize);
87 if (!mem)
88 return NULL;
89 hash = mem;
90 mem = hash + hsize;
91 entry = mem;
92
93 memset(hash, 0, hsize * sizeof(*hash));
94
95 hash_count = calloc(hsize, sizeof(*hash_count));
96 if (!hash_count) {
97 free(hash);
98 return NULL;
99 }
100
101 prev_val = ~0;
102 for (data = buffer + entries * RABIN_WINDOW - RABIN_WINDOW;
103 data >= buffer;
104 data -= RABIN_WINDOW) {
105 unsigned int val = 0;
106 for (i = 1; i <= RABIN_WINDOW; i++)
107 val = ((val << 8) | data[i]) ^ T[val >> RABIN_SHIFT];
108 if (val == prev_val) {
109 entry[-1].entry.ptr = data + RABIN_WINDOW;
110 --entries;
111 } else {
112 prev_val = val;
113 i = val & hmask;
114 entry->entry.ptr = data + RABIN_WINDOW;
115 entry->entry.val = val;
116 entry->next = hash[i];
117 hash[i] = entry++;
118 hash_count[i]++;
119 }
120 }
121
122 for (i = 0; i < hsize; i++) {
123 int acc;
124
125 if (hash_count[i] <= HASH_LIMIT)
126 continue;
127
128 entries -= hash_count[i] - HASH_LIMIT;
129
130 entry = hash[i];
131 acc = 0;
132
133 do {
134 acc += hash_count[i] - HASH_LIMIT;
135 if (acc > 0) {
136 struct unpacked_index_entry *keep = entry;
137 do {
138 entry = entry->next;
139 acc -= HASH_LIMIT;
140 } while (acc > 0);
141 keep->next = entry->next;
142 }
143 entry = entry->next;
144 } while (entry);
145 }
146 free(hash_count);
147
148 memsize = sizeof(*index)
149 + sizeof(*packed_hash) * (hsize+1)
150 + sizeof(*packed_entry) * entries;
151 mem = malloc(memsize);
152 if (!mem) {
153 free(hash);
154 return NULL;
155 }
156
157 index = mem;
158 index->memsize = memsize;
159 index->src_buf = buf;
160 index->src_size = bufsize;
161 index->hash_mask = hmask;
162
163 mem = index->hash;
164 packed_hash = mem;
165 mem = packed_hash + (hsize+1);
166 packed_entry = mem;
167
168 for (i = 0; i < hsize; i++) {
169 packed_hash[i] = packed_entry;
170 for (entry = hash[i]; entry; entry = entry->next)
171 *packed_entry++ = entry->entry;
172 }
173
174 packed_hash[hsize] = packed_entry;
175
176 assert(packed_entry - (struct index_entry *)mem == entries);
177 free(hash);
178
179 return index;
180}
181
182void free_delta_index(struct delta_index *index)
183{
184 free(index);
185}
186
187unsigned long sizeof_delta_index(struct delta_index *index)
188{
189 if (index)
190 return index->memsize;
191 else
192 return 0;
193}
194
195#define MAX_OP_SIZE (5 + 5 + 1 + RABIN_WINDOW + 7)
196
197void *
198create_delta(const struct delta_index *index,
199 const void *trg_buf, unsigned long trg_size,
200 unsigned long *delta_size, unsigned long max_size)
201{
202 unsigned int i, val;
203 off_t outpos, moff;
204 size_t l, outsize, msize;
205 int inscnt;
206 const unsigned char *ref_data, *ref_top, *data, *top;
207 unsigned char *out;
208
209 *delta_size = 0;
210
211 if (!trg_buf || !trg_size)
212 return NULL;
213
214 outpos = 0;
215 outsize = 8192;
216 if (max_size && outsize >= max_size)
217 outsize = max_size + MAX_OP_SIZE + 1;
218 out = malloc(outsize);
219 if (!out)
220 return NULL;
221
222 l = index->src_size;
223 while (l >= 0x80) {
224 out[outpos++] = l | 0x80;
225 l >>= 7;
226 }
227 out[outpos++] = l;
228
229 l = trg_size;
230 while (l >= 0x80) {
231 out[outpos++] = l | 0x80;
232 l >>= 7;
233 }
234 out[outpos++] = l;
235
236 ref_data = index->src_buf;
237 ref_top = ref_data + index->src_size;
238 data = trg_buf;
239 top = (const unsigned char *) trg_buf + trg_size;
240
241 outpos++;
242 val = 0;
243 for (i = 0; i < RABIN_WINDOW && data < top; i++, data++) {
244 out[outpos++] = *data;
245 val = ((val << 8) | *data) ^ T[val >> RABIN_SHIFT];
246 }
247 inscnt = i;
248
249 moff = 0;
250 msize = 0;
251 while (data < top) {
252 if (msize < 4096) {
253 struct index_entry *entry;
254 val ^= U[data[-RABIN_WINDOW]];
255 val = ((val << 8) | *data) ^ T[val >> RABIN_SHIFT];
256 i = val & index->hash_mask;
257 for (entry = index->hash[i]; entry < index->hash[i+1]; entry++) {
258 const unsigned char *ref = entry->ptr;
259 const unsigned char *src = data;
260 unsigned int ref_size = ref_top - ref;
261 if (entry->val != val)
262 continue;
263 if (ref_size > top - src)
264 ref_size = top - src;
265 if (ref_size <= msize)
266 break;
267 while (ref_size-- && *src++ == *ref)
268 ref++;
269 if (msize < ref - entry->ptr) {
270 msize = ref - entry->ptr;
271 moff = entry->ptr - ref_data;
272 if (msize >= 4096)
273 break;
274 }
275 }
276 }
277
278 if (msize < 4) {
279 if (!inscnt)
280 outpos++;
281 out[outpos++] = *data++;
282 inscnt++;
283 if (inscnt == 0x7f) {
284 out[outpos - inscnt - 1] = inscnt;
285 inscnt = 0;
286 }
287 msize = 0;
288 } else {
289 unsigned int left;
290 unsigned char *op;
291
292 if (inscnt) {
293 while (moff && ref_data[moff-1] == data[-1]) {
294 msize++;
295 moff--;
296 data--;
297 outpos--;
298 if (--inscnt)
299 continue;
300 outpos--;
301 inscnt--;
302 break;
303 }
304 out[outpos - inscnt - 1] = inscnt;
305 inscnt = 0;
306 }
307
308 left = (msize < 0x10000) ? 0 : (msize - 0x10000);
309 msize -= left;
310
311 op = out + outpos++;
312 i = 0x80;
313
314 if (moff & 0x000000ff)
315 out[outpos++] = moff >> 0, i |= 0x01;
316 if (moff & 0x0000ff00)
317 out[outpos++] = moff >> 8, i |= 0x02;
318 if (moff & 0x00ff0000)
319 out[outpos++] = moff >> 16, i |= 0x04;
320 if (moff & 0xff000000)
321 out[outpos++] = moff >> 24, i |= 0x08;
322
323 if (msize & 0x00ff)
324 out[outpos++] = msize >> 0, i |= 0x10;
325 if (msize & 0xff00)
326 out[outpos++] = msize >> 8, i |= 0x20;
327
328 *op = i;
329
330 data += msize;
331 moff += msize;
332 msize = left;
333
334 if (moff > 0xffffffff)
335 msize = 0;
336
337 if (msize < 4096) {
338 int j;
339 val = 0;
340 for (j = -RABIN_WINDOW; j < 0; j++)
341 val = ((val << 8) | data[j])
342 ^ T[val >> RABIN_SHIFT];
343 }
344 }
345
346 if (outpos >= outsize - MAX_OP_SIZE) {
347 void *tmp = out;
348 outsize = outsize * 3 / 2;
349 if (max_size && outsize >= max_size)
350 outsize = max_size + MAX_OP_SIZE + 1;
351 if (max_size && outpos > max_size)
352 break;
353 out = realloc(out, outsize);
354 if (!out) {
355 free(tmp);
356 return NULL;
357 }
358 }
359 }
360
361 if (inscnt)
362 out[outpos - inscnt - 1] = inscnt;
363
364 if (max_size && outpos > max_size) {
365 free(out);
366 return NULL;
367 }
368
369 *delta_size = outpos;
370 return out;
371}
372}}}