/*
* 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 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.io.OutputStream;
import java.text.MessageFormat;
import org.eclipse.jgit.diff.Edit;
import org.eclipse.jgit.diff.EditList;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.AbbreviatedObjectId;
import org.eclipse.jgit.util.MutableInteger;
/** Hunk header describing the layout of a single block of lines */
public class HunkHeader {
/** Details about an old image of the file. */
public abstract static class OldImage {
/** First line number the hunk starts on in this file. */
int startLine;
/** Total number of lines this hunk covers in this file. */
int lineCount;
/** Number of lines deleted by the post-image from this file. */
int nDeleted;
/** Number of lines added by the post-image not in this file. */
int nAdded;
/** @return first line number the hunk starts on in this file. */
public int getStartLine() {
return startLine;
}
/** @return total number of lines this hunk covers in this file. */
public int getLineCount() {
return lineCount;
}
/** @return number of lines deleted by the post-image from this file. */
public int getLinesDeleted() {
return nDeleted;
}
/** @return number of lines added by the post-image not in this file. */
public int getLinesAdded() {
return nAdded;
}
/** @return object id of the pre-image file. */
public abstract AbbreviatedObjectId getId();
}
final FileHeader file;
/** Offset within {@link #file}.buf to the "@@ -" line. */
final int startOffset;
/** Position 1 past the end of this hunk within {@link #file}'s buf. */
int endOffset;
private final OldImage old;
/** First line number in the post-image file where the hunk starts */
int newStartLine;
/** Total number of post-image lines this hunk covers (context + inserted) */
int newLineCount;
/** Total number of lines of context appearing in this hunk */
int nContext;
private EditList editList;
HunkHeader(final FileHeader fh, final int offset) {
this(fh, offset, new OldImage() {
@Override
public AbbreviatedObjectId getId() {
return fh.getOldId();
}
});
}
HunkHeader(final FileHeader fh, final int offset, final OldImage oi) {
file = fh;
startOffset = offset;
old = oi;
}
HunkHeader(final FileHeader fh, final EditList editList) {
this(fh, fh.buf.length);
this.editList = editList;
endOffset = startOffset;
nContext = 0;
if (editList.isEmpty()) {
newStartLine = 0;
newLineCount = 0;
} else {
newStartLine = editList.get(0).getBeginB();
Edit last = editList.get(editList.size() - 1);
newLineCount = last.getEndB() - newStartLine;
}
}
/** @return header for the file this hunk applies to */
public FileHeader getFileHeader() {
return file;
}
/** @return the byte array holding this hunk's patch script. */
public byte[] getBuffer() {
return file.buf;
}
/** @return offset the start of this hunk in {@link #getBuffer()}. */
public int getStartOffset() {
return startOffset;
}
/** @return offset one past the end of the hunk in {@link #getBuffer()}. */
public int getEndOffset() {
return endOffset;
}
/** @return information about the old image mentioned in this hunk. */
public OldImage getOldImage() {
return old;
}
/** @return first line number in the post-image file where the hunk starts */
public int getNewStartLine() {
return newStartLine;
}
/** @return Total number of post-image lines this hunk covers */
public int getNewLineCount() {
return newLineCount;
}
/** @return total number of lines of context appearing in this hunk */
public int getLinesContext() {
return nContext;
}
/** @return a list describing the content edits performed within the hunk. */
public EditList toEditList() {
if (editList == null) {
editList = new EditList();
final byte[] buf = file.buf;
int c = nextLF(buf, startOffset);
int oLine = old.startLine;
int nLine = newStartLine;
Edit in = null;
SCAN: for (; c < endOffset; c = nextLF(buf, c)) {
switch (buf[c]) {
case ' ':
case '\n':
in = null;
oLine++;
nLine++;
continue;
case '-':
if (in == null) {
in = new Edit(oLine - 1, nLine - 1);
editList.add(in);
}
oLine++;
in.extendA();
continue;
case '+':
if (in == null) {
in = new Edit(oLine - 1, nLine - 1);
editList.add(in);
}
nLine++;
in.extendB();
continue;
case '\\': // Matches "\ No newline at end of file"
continue;
default:
break SCAN;
}
}
}
return editList;
}
void parseHeader() {
// Parse "@@ -236,9 +236,9 @@ protected boolean"
//
final byte[] buf = file.buf;
final MutableInteger ptr = new MutableInteger();
ptr.value = nextLF(buf, startOffset, ' ');
old.startLine = -parseBase10(buf, ptr.value, ptr);
if (buf[ptr.value] == ',')
old.lineCount = parseBase10(buf, ptr.value + 1, ptr);
else
old.lineCount = 1;
newStartLine = parseBase10(buf, ptr.value + 1, ptr);
if (buf[ptr.value] == ',')
newLineCount = parseBase10(buf, ptr.value + 1, ptr);
else
newLineCount = 1;
}
int parseBody(final Patch script, final int end) {
final byte[] buf = file.buf;
int c = nextLF(buf, startOffset), last = c;
old.nDeleted = 0;
old.nAdded = 0;
SCAN: for (; c < end; last = c, c = nextLF(buf, c)) {
switch (buf[c]) {
case ' ':
case '\n':
nContext++;
continue;
case '-':
old.nDeleted++;
continue;
case '+':
old.nAdded++;
continue;
case '\\': // Matches "\ No newline at end of file"
continue;
default:
break SCAN;
}
}
if (last < end && nContext + old.nDeleted - 1 == old.lineCount
&& nContext + old.nAdded == newLineCount
&& match(buf, last, Patch.SIG_FOOTER) >= 0) {
// This is an extremely common occurrence of "corruption".
// Users add footers with their signatures after this mark,
// and git diff adds the git executable version number.
// Let it slide; the hunk otherwise looked sound.
//
old.nDeleted--;
return last;
}
if (nContext + old.nDeleted < old.lineCount) {
final int missingCount = old.lineCount - (nContext + old.nDeleted);
script.error(buf, startOffset, MessageFormat.format(
JGitText.get().truncatedHunkOldLinesMissing,
Integer.valueOf(missingCount)));
} else if (nContext + old.nAdded < newLineCount) {
final int missingCount = newLineCount - (nContext + old.nAdded);
script.error(buf, startOffset, MessageFormat.format(
JGitText.get().truncatedHunkNewLinesMissing,
Integer.valueOf(missingCount)));
} else if (nContext + old.nDeleted > old.lineCount
|| nContext + old.nAdded > newLineCount) {
final String oldcnt = old.lineCount + ":" + newLineCount; //$NON-NLS-1$
final String newcnt = (nContext + old.nDeleted) + ":" //$NON-NLS-1$
+ (nContext + old.nAdded);
script.warn(buf, startOffset, MessageFormat.format(
JGitText.get().hunkHeaderDoesNotMatchBodyLineCountOf, oldcnt, newcnt));
}
return c;
}
void extractFileLines(final OutputStream[] out) throws IOException {
final byte[] buf = file.buf;
int ptr = startOffset;
int eol = nextLF(buf, ptr);
if (endOffset <= eol)
return;
// Treat the hunk header as though it were from the ancestor,
// as it may have a function header appearing after it which
// was copied out of the ancestor file.
//
out[0].write(buf, ptr, eol - ptr);
SCAN: for (ptr = eol; ptr < endOffset; ptr = eol) {
eol = nextLF(buf, ptr);
switch (buf[ptr]) {
case ' ':
case '\n':
case '\\':
out[0].write(buf, ptr, eol - ptr);
out[1].write(buf, ptr, eol - ptr);
break;
case '-':
out[0].write(buf, ptr, eol - ptr);
break;
case '+':
out[1].write(buf, ptr, eol - ptr);
break;
default:
break SCAN;
}
}
}
void extractFileLines(final StringBuilder sb, final String[] text,
final int[] offsets) {
final byte[] buf = file.buf;
int ptr = startOffset;
int eol = nextLF(buf, ptr);
if (endOffset <= eol)
return;
copyLine(sb, text, offsets, 0);
SCAN: for (ptr = eol; ptr < endOffset; ptr = eol) {
eol = nextLF(buf, ptr);
switch (buf[ptr]) {
case ' ':
case '\n':
case '\\':
copyLine(sb, text, offsets, 0);
skipLine(text, offsets, 1);
break;
case '-':
copyLine(sb, text, offsets, 0);
break;
case '+':
copyLine(sb, text, offsets, 1);
break;
default:
break SCAN;
}
}
}
void copyLine(final StringBuilder sb, final String[] text,
final int[] offsets, final int fileIdx) {
final String s = text[fileIdx];
final int start = offsets[fileIdx];
int end = s.indexOf('\n', start);
if (end < 0)
end = s.length();
else
end++;
sb.append(s, start, end);
offsets[fileIdx] = end;
}
void skipLine(final String[] text, final int[] offsets,
final int fileIdx) {
final String s = text[fileIdx];
final int end = s.indexOf('\n', offsets[fileIdx]);
offsets[fileIdx] = end < 0 ? s.length() : end + 1;
}
@SuppressWarnings("nls")
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append("HunkHeader[");
buf.append(getOldImage().getStartLine());
buf.append(',');
buf.append(getOldImage().getLineCount());
buf.append("->");
buf.append(getNewStartLine()).append(',').append(getNewLineCount());
buf.append(']');
return buf.toString();
}
}