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

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

r1
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
17{{{#!syntax cpp
18struct delta_index {
19 unsigned long memsize;
20 const void *src_buf;
21 unsigned long src_size;
22 unsigned int hash_mask;
23 struct index_entry *hash[FLEX_ARRAY];
24};
25
26struct delta_index * create_delta_index(const void *buf, unsigned long bufsize)
27{
28 unsigned int i, hsize, hmask, entries, prev_val, *hash_count;
29 const unsigned char *data, *buffer = buf;
30 struct delta_index *index;
31 struct unpacked_index_entry *entry, **hash;
32 struct index_entry *packed_entry, **packed_hash;
33 void *mem;
34 unsigned long memsize;
35
36 if (!buf || !bufsize)
37 return NULL;
38
39 entries = (bufsize - 1) / RABIN_WINDOW;
40 if (bufsize >= 0xffffffffUL) {
41 entries = 0xfffffffeU / RABIN_WINDOW;
42 }
43 hsize = entries / 4;
44 for (i = 4; (1u << i) < hsize; i++);
45 hsize = 1 << i;
46 hmask = hsize - 1;
47
48 /* allocate lookup index */
49 memsize = sizeof(*hash) * hsize +
50 sizeof(*entry) * entries;
51 mem = malloc(memsize);
52 if (!mem)
53 return NULL;
54 hash = mem;
55 mem = hash + hsize;
56 entry = mem;
57
58 memset(hash, 0, hsize * sizeof(*hash));
59
60 hash_count = calloc(hsize, sizeof(*hash_count));
61 if (!hash_count) {
62 free(hash);
63 return NULL;
64 }
65
66 prev_val = ~0;
67 for (data = buffer + entries * RABIN_WINDOW - RABIN_WINDOW;
68 data >= buffer;
69 data -= RABIN_WINDOW) {
70 unsigned int val = 0;
71 for (i = 1; i <= RABIN_WINDOW; i++)
72 val = ((val << 8) | data[i]) ^ T[val >> RABIN_SHIFT];
73 if (val == prev_val) {
74 entry[-1].entry.ptr = data + RABIN_WINDOW;
75 --entries;
76 } else {
77 prev_val = val;
78 i = val & hmask;
79 entry->entry.ptr = data + RABIN_WINDOW;
80 entry->entry.val = val;
81 entry->next = hash[i];
82 hash[i] = entry++;
83 hash_count[i]++;
84 }
85 }
86
87 for (i = 0; i < hsize; i++) {
88 int acc;
89
90 if (hash_count[i] <= HASH_LIMIT)
91 continue;
92
93 entries -= hash_count[i] - HASH_LIMIT;
94
95 entry = hash[i];
96 acc = 0;
97
98 do {
99 acc += hash_count[i] - HASH_LIMIT;
100 if (acc > 0) {
101 struct unpacked_index_entry *keep = entry;
102 do {
103 entry = entry->next;
104 acc -= HASH_LIMIT;
105 } while (acc > 0);
106 keep->next = entry->next;
107 }
108 entry = entry->next;
109 } while (entry);
110 }
111 free(hash_count);
112
113 memsize = sizeof(*index)
114 + sizeof(*packed_hash) * (hsize+1)
115 + sizeof(*packed_entry) * entries;
116 mem = malloc(memsize);
117 if (!mem) {
118 free(hash);
119 return NULL;
120 }
121
122 index = mem;
123 index->memsize = memsize;
124 index->src_buf = buf;
125 index->src_size = bufsize;
126 index->hash_mask = hmask;
127
128 mem = index->hash;
129 packed_hash = mem;
130 mem = packed_hash + (hsize+1);
131 packed_entry = mem;
132
133 for (i = 0; i < hsize; i++) {
134 packed_hash[i] = packed_entry;
135 for (entry = hash[i]; entry; entry = entry->next)
136 *packed_entry++ = entry->entry;
137 }
138
139 packed_hash[hsize] = packed_entry;
140
141 assert(packed_entry - (struct index_entry *)mem == entries);
142 free(hash);
143
144 return index;
145}
146
147void free_delta_index(struct delta_index *index)
148{
149 free(index);
150}
151
152unsigned long sizeof_delta_index(struct delta_index *index)
153{
154 if (index)
155 return index->memsize;
156 else
157 return 0;
158}
159
160#define MAX_OP_SIZE (5 + 5 + 1 + RABIN_WINDOW + 7)
161
162void *
163create_delta(const struct delta_index *index,
164 const void *trg_buf, unsigned long trg_size,
165 unsigned long *delta_size, unsigned long max_size)
166{
167 unsigned int i, val;
168 off_t outpos, moff;
169 size_t l, outsize, msize;
170 int inscnt;
171 const unsigned char *ref_data, *ref_top, *data, *top;
172 unsigned char *out;
173
174 *delta_size = 0;
175
176 if (!trg_buf || !trg_size)
177 return NULL;
178
179 outpos = 0;
180 outsize = 8192;
181 if (max_size && outsize >= max_size)
182 outsize = max_size + MAX_OP_SIZE + 1;
183 out = malloc(outsize);
184 if (!out)
185 return NULL;
186
187 l = index->src_size;
188 while (l >= 0x80) {
189 out[outpos++] = l | 0x80;
190 l >>= 7;
191 }
192 out[outpos++] = l;
193
194 l = trg_size;
195 while (l >= 0x80) {
196 out[outpos++] = l | 0x80;
197 l >>= 7;
198 }
199 out[outpos++] = l;
200
201 ref_data = index->src_buf;
202 ref_top = ref_data + index->src_size;
203 data = trg_buf;
204 top = (const unsigned char *) trg_buf + trg_size;
205
206 outpos++;
207 val = 0;
208 for (i = 0; i < RABIN_WINDOW && data < top; i++, data++) {
209 out[outpos++] = *data;
210 val = ((val << 8) | *data) ^ T[val >> RABIN_SHIFT];
211 }
212 inscnt = i;
213
214 moff = 0;
215 msize = 0;
216 while (data < top) {
217 if (msize < 4096) {
218 struct index_entry *entry;
219 val ^= U[data[-RABIN_WINDOW]];
220 val = ((val << 8) | *data) ^ T[val >> RABIN_SHIFT];
221 i = val & index->hash_mask;
222 for (entry = index->hash[i]; entry < index->hash[i+1]; entry++) {
223 const unsigned char *ref = entry->ptr;
224 const unsigned char *src = data;
225 unsigned int ref_size = ref_top - ref;
226 if (entry->val != val)
227 continue;
228 if (ref_size > top - src)
229 ref_size = top - src;
230 if (ref_size <= msize)
231 break;
232 while (ref_size-- && *src++ == *ref)
233 ref++;
234 if (msize < ref - entry->ptr) {
235 msize = ref - entry->ptr;
236 moff = entry->ptr - ref_data;
237 if (msize >= 4096)
238 break;
239 }
240 }
241 }
242
243 if (msize < 4) {
244 if (!inscnt)
245 outpos++;
246 out[outpos++] = *data++;
247 inscnt++;
248 if (inscnt == 0x7f) {
249 out[outpos - inscnt - 1] = inscnt;
250 inscnt = 0;
251 }
252 msize = 0;
253 } else {
254 unsigned int left;
255 unsigned char *op;
256
257 if (inscnt) {
258 while (moff && ref_data[moff-1] == data[-1]) {
259 msize++;
260 moff--;
261 data--;
262 outpos--;
263 if (--inscnt)
264 continue;
265 outpos--;
266 inscnt--;
267 break;
268 }
269 out[outpos - inscnt - 1] = inscnt;
270 inscnt = 0;
271 }
272
273 left = (msize < 0x10000) ? 0 : (msize - 0x10000);
274 msize -= left;
275
276 op = out + outpos++;
277 i = 0x80;
278
279 if (moff & 0x000000ff)
280 out[outpos++] = moff >> 0, i |= 0x01;
281 if (moff & 0x0000ff00)
282 out[outpos++] = moff >> 8, i |= 0x02;
283 if (moff & 0x00ff0000)
284 out[outpos++] = moff >> 16, i |= 0x04;
285 if (moff & 0xff000000)
286 out[outpos++] = moff >> 24, i |= 0x08;
287
288 if (msize & 0x00ff)
289 out[outpos++] = msize >> 0, i |= 0x10;
290 if (msize & 0xff00)
291 out[outpos++] = msize >> 8, i |= 0x20;
292
293 *op = i;
294
295 data += msize;
296 moff += msize;
297 msize = left;
298
299 if (moff > 0xffffffff)
300 msize = 0;
301
302 if (msize < 4096) {
303 int j;
304 val = 0;
305 for (j = -RABIN_WINDOW; j < 0; j++)
306 val = ((val << 8) | data[j])
307 ^ T[val >> RABIN_SHIFT];
308 }
309 }
310
311 if (outpos >= outsize - MAX_OP_SIZE) {
312 void *tmp = out;
313 outsize = outsize * 3 / 2;
314 if (max_size && outsize >= max_size)
315 outsize = max_size + MAX_OP_SIZE + 1;
316 if (max_size && outpos > max_size)
317 break;
318 out = realloc(out, outsize);
319 if (!out) {
320 free(tmp);
321 return NULL;
322 }
323 }
324 }
325
326 if (inscnt)
327 out[outpos - inscnt - 1] = inscnt;
328
329 if (max_size && outpos > max_size) {
330 free(out);
331 return NULL;
332 }
333
334 *delta_size = outpos;
335 return out;
336}
337}}}