1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
|
/*
* Copyright (C) 2008-2009, Google Inc.
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.patch;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.eclipse.jgit.lib.Constants.encodeASCII;
import static org.eclipse.jgit.util.RawParseUtils.decode;
import static org.eclipse.jgit.util.RawParseUtils.decodeNoFallback;
import static org.eclipse.jgit.util.RawParseUtils.extractBinaryString;
import static org.eclipse.jgit.util.RawParseUtils.match;
import static org.eclipse.jgit.util.RawParseUtils.nextLF;
import static org.eclipse.jgit.util.RawParseUtils.parseBase10;
import java.io.IOException;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.EditList;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.AbbreviatedObjectId;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.util.QuotedString;
import org.eclipse.jgit.util.RawParseUtils;
import org.eclipse.jgit.util.TemporaryBuffer;
/**
* Patch header describing an action for a single file path.
*/
public class FileHeader extends DiffEntry {
private static final byte[] OLD_MODE = encodeASCII("old mode "); //$NON-NLS-1$
private static final byte[] NEW_MODE = encodeASCII("new mode "); //$NON-NLS-1$
static final byte[] DELETED_FILE_MODE = encodeASCII("deleted file mode "); //$NON-NLS-1$
static final byte[] NEW_FILE_MODE = encodeASCII("new file mode "); //$NON-NLS-1$
private static final byte[] COPY_FROM = encodeASCII("copy from "); //$NON-NLS-1$
private static final byte[] COPY_TO = encodeASCII("copy to "); //$NON-NLS-1$
private static final byte[] RENAME_OLD = encodeASCII("rename old "); //$NON-NLS-1$
private static final byte[] RENAME_NEW = encodeASCII("rename new "); //$NON-NLS-1$
private static final byte[] RENAME_FROM = encodeASCII("rename from "); //$NON-NLS-1$
private static final byte[] RENAME_TO = encodeASCII("rename to "); //$NON-NLS-1$
private static final byte[] SIMILARITY_INDEX = encodeASCII("similarity index "); //$NON-NLS-1$
private static final byte[] DISSIMILARITY_INDEX = encodeASCII("dissimilarity index "); //$NON-NLS-1$
static final byte[] INDEX = encodeASCII("index "); //$NON-NLS-1$
static final byte[] OLD_NAME = encodeASCII("--- "); //$NON-NLS-1$
static final byte[] NEW_NAME = encodeASCII("+++ "); //$NON-NLS-1$
/** Type of patch used by this file. */
public static enum PatchType {
/** A traditional unified diff style patch of a text file. */
UNIFIED,
/** An empty patch with a message "Binary files ... differ" */
BINARY,
/** A Git binary patch, holding pre and post image deltas */
GIT_BINARY;
}
/** Buffer holding the patch data for this file. */
final byte[] buf;
/** Offset within {@link #buf} to the "diff ..." line. */
final int startOffset;
/** Position 1 past the end of this file within {@link #buf}. */
int endOffset;
/** Type of patch used to modify this file */
PatchType patchType;
/** The hunks of this file */
private List<HunkHeader> hunks;
/** If {@link #patchType} is {@link PatchType#GIT_BINARY}, the new image */
BinaryHunk forwardBinaryHunk;
/** If {@link #patchType} is {@link PatchType#GIT_BINARY}, the old image */
BinaryHunk reverseBinaryHunk;
/**
* Constructs a new FileHeader
*
* @param headerLines
* buffer holding the diff header for this file
* @param edits
* the edits for this file
* @param type
* the type of patch used to modify this file
*/
public FileHeader(byte[] headerLines, EditList edits, PatchType type) {
this(headerLines, 0);
endOffset = headerLines.length;
int ptr = parseGitFileName(Patch.DIFF_GIT.length, headerLines.length);
parseGitHeaders(ptr, headerLines.length);
this.patchType = type;
addHunk(new HunkHeader(this, edits));
}
FileHeader(byte[] b, int offset) {
buf = b;
startOffset = offset;
changeType = ChangeType.MODIFY; // unless otherwise designated
patchType = PatchType.UNIFIED;
}
int getParentCount() {
return 1;
}
/**
* Get the byte array holding this file's patch script.
*
* @return the byte array holding this file's patch script.
*/
public byte[] getBuffer() {
return buf;
}
/**
* Get offset of the start of this file's script in {@link #getBuffer()}.
*
* @return offset of the start of this file's script in
* {@link #getBuffer()}.
*/
public int getStartOffset() {
return startOffset;
}
/**
* Get offset one past the end of the file script.
*
* @return offset one past the end of the file script.
*/
public int getEndOffset() {
return endOffset;
}
/**
* Convert the patch script for this file into a string.
* <p>
* The default character encoding
* ({@link java.nio.charset.StandardCharsets#UTF_8}) is assumed for both the
* old and new files.
*
* @return the patch script, as a Unicode string.
*/
public String getScriptText() {
return getScriptText(null, null);
}
/**
* Convert the patch script for this file into a string.
*
* @param oldCharset
* hint character set to decode the old lines with.
* @param newCharset
* hint character set to decode the new lines with.
* @return the patch script, as a Unicode string.
*/
public String getScriptText(Charset oldCharset, Charset newCharset) {
return getScriptText(new Charset[] { oldCharset, newCharset });
}
String getScriptText(Charset[] charsetGuess) {
if (getHunks().isEmpty()) {
// If we have no hunks then we can safely assume the entire
// patch is a binary style patch, or a meta-data only style
// patch. Either way the encoding of the headers should be
// strictly 7-bit US-ASCII and the body is either 7-bit ASCII
// (due to the base 85 encoding used for a BinaryHunk) or is
// arbitrary noise we have chosen to ignore and not understand
// (e.g. the message "Binary files ... differ").
//
return extractBinaryString(buf, startOffset, endOffset);
}
if (charsetGuess != null && charsetGuess.length != getParentCount() + 1)
throw new IllegalArgumentException(MessageFormat.format(
JGitText.get().expectedCharacterEncodingGuesses,
Integer.valueOf(getParentCount() + 1)));
if (trySimpleConversion(charsetGuess)) {
Charset cs = charsetGuess != null ? charsetGuess[0] : null;
if (cs == null) {
cs = UTF_8;
}
try {
return decodeNoFallback(cs, buf, startOffset, endOffset);
} catch (CharacterCodingException cee) {
// Try the much slower, more-memory intensive version which
// can handle a character set conversion patch.
}
}
final StringBuilder r = new StringBuilder(endOffset - startOffset);
// Always treat the headers as US-ASCII; Git file names are encoded
// in a C style escape if any character has the high-bit set.
//
final int hdrEnd = getHunks().get(0).getStartOffset();
for (int ptr = startOffset; ptr < hdrEnd;) {
final int eol = Math.min(hdrEnd, nextLF(buf, ptr));
r.append(extractBinaryString(buf, ptr, eol));
ptr = eol;
}
final String[] files = extractFileLines(charsetGuess);
final int[] offsets = new int[files.length];
for (HunkHeader h : getHunks())
h.extractFileLines(r, files, offsets);
return r.toString();
}
private static boolean trySimpleConversion(Charset[] charsetGuess) {
if (charsetGuess == null)
return true;
for (int i = 1; i < charsetGuess.length; i++) {
if (charsetGuess[i] != charsetGuess[0])
return false;
}
return true;
}
private String[] extractFileLines(Charset[] csGuess) {
final TemporaryBuffer[] tmp = new TemporaryBuffer[getParentCount() + 1];
try {
for (int i = 0; i < tmp.length; i++)
tmp[i] = new TemporaryBuffer.Heap(Integer.MAX_VALUE);
for (HunkHeader h : getHunks())
h.extractFileLines(tmp);
final String[] r = new String[tmp.length];
for (int i = 0; i < tmp.length; i++) {
Charset cs = csGuess != null ? csGuess[i] : null;
if (cs == null) {
cs = UTF_8;
}
r[i] = RawParseUtils.decode(cs, tmp[i].toByteArray());
}
return r;
} catch (IOException ioe) {
throw new RuntimeException(JGitText.get().cannotConvertScriptToText, ioe);
}
}
/**
* Get style of patch used to modify this file.
*
* @return style of patch used to modify this file.
*/
public PatchType getPatchType() {
return patchType;
}
/**
* Whether this patch modifies metadata about a file
*
* @return {@code true} if this patch modifies metadata about a file .
*/
public boolean hasMetaDataChanges() {
return changeType != ChangeType.MODIFY || newMode != oldMode;
}
/**
* Get hunks altering this file; in order of appearance in patch
*
* @return hunks altering this file; in order of appearance in patch.
*/
public List<? extends HunkHeader> getHunks() {
if (hunks == null)
return Collections.emptyList();
return hunks;
}
void addHunk(HunkHeader h) {
if (h.getFileHeader() != this)
throw new IllegalArgumentException(JGitText.get().hunkBelongsToAnotherFile);
if (hunks == null)
hunks = new ArrayList<>();
hunks.add(h);
}
HunkHeader newHunkHeader(int offset) {
return new HunkHeader(this, offset);
}
/**
* Get the new-image delta/literal if this is a
* {@link PatchType#GIT_BINARY}.
*
* @return the new-image delta/literal if this is a
* {@link PatchType#GIT_BINARY}.
*/
public BinaryHunk getForwardBinaryHunk() {
return forwardBinaryHunk;
}
/**
* Get the old-image delta/literal if this is a
* {@link PatchType#GIT_BINARY}.
*
* @return the old-image delta/literal if this is a
* {@link PatchType#GIT_BINARY}.
*/
public BinaryHunk getReverseBinaryHunk() {
return reverseBinaryHunk;
}
/**
* Convert to a list describing the content edits performed on this file.
*
* @return a list describing the content edits performed on this file.
*/
public EditList toEditList() {
final EditList r = new EditList();
for (HunkHeader hunk : hunks)
r.addAll(hunk.toEditList());
return r;
}
/**
* Parse a "diff --git" or "diff --cc" line.
*
* @param ptr
* first character after the "diff --git " or "diff --cc " part.
* @param end
* one past the last position to parse.
* @return first character after the LF at the end of the line; -1 on error.
*/
int parseGitFileName(int ptr, int end) {
final int eol = nextLF(buf, ptr);
final int bol = ptr;
if (eol >= end) {
return -1;
}
// buffer[ptr..eol] looks like "a/foo b/foo\n". After the first
// A regex to match this is "^[^/]+/(.*?) [^/+]+/\1\n$". There
// is only one way to split the line such that text to the left
// of the space matches the text to the right, excluding the part
// before the first slash.
//
final int aStart = nextLF(buf, ptr, '/');
if (aStart >= eol)
return eol;
while (ptr < eol) {
final int sp = nextLF(buf, ptr, ' ');
if (sp >= eol) {
// We can't split the header, it isn't valid.
// This may be OK if this is a rename patch.
//
return eol;
}
final int bStart = nextLF(buf, sp, '/');
if (bStart >= eol)
return eol;
// If buffer[aStart..sp - 1] = buffer[bStart..eol - 1]
// we have a valid split.
//
if (eq(aStart, sp - 1, bStart, eol - 1)) {
if (buf[bol] == '"') {
// We're a double quoted name. The region better end
// in a double quote too, and we need to decode the
// characters before reading the name.
//
if (buf[sp - 2] != '"') {
return eol;
}
oldPath = QuotedString.GIT_PATH.dequote(buf, bol, sp - 1);
oldPath = p1(oldPath);
} else {
oldPath = decode(UTF_8, buf, aStart, sp - 1);
}
newPath = oldPath;
return eol;
}
// This split wasn't correct. Move past the space and try
// another split as the space must be part of the file name.
//
ptr = sp;
}
return eol;
}
int parseGitHeaders(int ptr, int end) {
while (ptr < end) {
final int eol = nextLF(buf, ptr);
if (isHunkHdr(buf, ptr, eol) >= 1) {
// First hunk header; break out and parse them later.
break;
} else if (match(buf, ptr, OLD_NAME) >= 0) {
parseOldName(ptr, eol);
} else if (match(buf, ptr, NEW_NAME) >= 0) {
parseNewName(ptr, eol);
} else if (match(buf, ptr, OLD_MODE) >= 0) {
oldMode = parseFileMode(ptr + OLD_MODE.length, eol);
} else if (match(buf, ptr, NEW_MODE) >= 0) {
newMode = parseFileMode(ptr + NEW_MODE.length, eol);
} else if (match(buf, ptr, DELETED_FILE_MODE) >= 0) {
oldMode = parseFileMode(ptr + DELETED_FILE_MODE.length, eol);
newMode = FileMode.MISSING;
changeType = ChangeType.DELETE;
} else if (match(buf, ptr, NEW_FILE_MODE) >= 0) {
parseNewFileMode(ptr, eol);
} else if (match(buf, ptr, COPY_FROM) >= 0) {
oldPath = parseName(oldPath, ptr + COPY_FROM.length, eol);
changeType = ChangeType.COPY;
} else if (match(buf, ptr, COPY_TO) >= 0) {
newPath = parseName(newPath, ptr + COPY_TO.length, eol);
changeType = ChangeType.COPY;
} else if (match(buf, ptr, RENAME_OLD) >= 0) {
oldPath = parseName(oldPath, ptr + RENAME_OLD.length, eol);
changeType = ChangeType.RENAME;
} else if (match(buf, ptr, RENAME_NEW) >= 0) {
newPath = parseName(newPath, ptr + RENAME_NEW.length, eol);
changeType = ChangeType.RENAME;
} else if (match(buf, ptr, RENAME_FROM) >= 0) {
oldPath = parseName(oldPath, ptr + RENAME_FROM.length, eol);
changeType = ChangeType.RENAME;
} else if (match(buf, ptr, RENAME_TO) >= 0) {
newPath = parseName(newPath, ptr + RENAME_TO.length, eol);
changeType = ChangeType.RENAME;
} else if (match(buf, ptr, SIMILARITY_INDEX) >= 0) {
score = parseBase10(buf, ptr + SIMILARITY_INDEX.length, null);
} else if (match(buf, ptr, DISSIMILARITY_INDEX) >= 0) {
score = parseBase10(buf, ptr + DISSIMILARITY_INDEX.length, null);
} else if (match(buf, ptr, INDEX) >= 0) {
parseIndexLine(ptr + INDEX.length, eol);
} else {
// Probably an empty patch (stat dirty).
break;
}
ptr = eol;
}
return ptr;
}
void parseOldName(int ptr, int eol) {
oldPath = p1(parseName(oldPath, ptr + OLD_NAME.length, eol));
if (oldPath == DEV_NULL)
changeType = ChangeType.ADD;
}
void parseNewName(int ptr, int eol) {
newPath = p1(parseName(newPath, ptr + NEW_NAME.length, eol));
if (newPath == DEV_NULL)
changeType = ChangeType.DELETE;
}
void parseNewFileMode(int ptr, int eol) {
oldMode = FileMode.MISSING;
newMode = parseFileMode(ptr + NEW_FILE_MODE.length, eol);
changeType = ChangeType.ADD;
}
int parseTraditionalHeaders(int ptr, int end) {
while (ptr < end) {
final int eol = nextLF(buf, ptr);
if (isHunkHdr(buf, ptr, eol) >= 1) {
// First hunk header; break out and parse them later.
break;
} else if (match(buf, ptr, OLD_NAME) >= 0) {
parseOldName(ptr, eol);
} else if (match(buf, ptr, NEW_NAME) >= 0) {
parseNewName(ptr, eol);
} else {
// Possibly an empty patch.
break;
}
ptr = eol;
}
return ptr;
}
private String parseName(String expect, int ptr, int end) {
if (ptr == end)
return expect;
String r;
if (buf[ptr] == '"') {
// New style GNU diff format
//
r = QuotedString.GIT_PATH.dequote(buf, ptr, end - 1);
} else {
// Older style GNU diff format, an optional tab ends the name.
//
int tab = end;
while (ptr < tab && buf[tab - 1] != '\t')
tab--;
if (ptr == tab)
tab = end;
r = decode(UTF_8, buf, ptr, tab - 1);
}
if (r.equals(DEV_NULL))
r = DEV_NULL;
return r;
}
private static String p1(final String r) {
final int s = r.indexOf('/');
return s > 0 ? r.substring(s + 1) : r;
}
FileMode parseFileMode(int ptr, int end) {
int tmp = 0;
while (ptr < end - 1) {
tmp <<= 3;
tmp += buf[ptr++] - '0';
}
return FileMode.fromBits(tmp);
}
void parseIndexLine(int ptr, int end) {
// "index $asha1..$bsha1[ $mode]" where $asha1 and $bsha1
// can be unique abbreviations
//
final int dot2 = nextLF(buf, ptr, '.');
final int mode = nextLF(buf, dot2, ' ');
oldId = AbbreviatedObjectId.fromString(buf, ptr, dot2 - 1);
newId = AbbreviatedObjectId.fromString(buf, dot2 + 1, mode - 1);
if (mode < end)
newMode = oldMode = parseFileMode(mode, end);
}
private boolean eq(int aPtr, int aEnd, int bPtr, int bEnd) {
if (aEnd - aPtr != bEnd - bPtr) {
return false;
}
while (aPtr < aEnd) {
if (buf[aPtr++] != buf[bPtr++])
return false;
}
return true;
}
/**
* Determine if this is a patch hunk header.
*
* @param buf
* the buffer to scan
* @param start
* first position in the buffer to evaluate
* @param end
* last position to consider; usually the end of the buffer (
* <code>buf.length</code>) or the first position on the next
* line. This is only used to avoid very long runs of '@' from
* killing the scan loop.
* @return the number of "ancestor revisions" in the hunk header. A
* traditional two-way diff ("@@ -...") returns 1; a combined diff
* for a 3 way-merge returns 3. If this is not a hunk header, 0 is
* returned instead.
*/
static int isHunkHdr(byte[] buf, int start, int end) {
int ptr = start;
while (ptr < end && buf[ptr] == '@')
ptr++;
if (ptr - start < 2)
return 0;
if (ptr == end || buf[ptr++] != ' ')
return 0;
if (ptr == end || buf[ptr++] != '-')
return 0;
return (ptr - 3) - start;
}
}
|