CombinedHunkHeader.java

  1. /*
  2.  * Copyright (C) 2008, Google Inc. and others
  3.  *
  4.  * This program and the accompanying materials are made available under the
  5.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  6.  * https://www.eclipse.org/org/documents/edl-v10.php.
  7.  *
  8.  * SPDX-License-Identifier: BSD-3-Clause
  9.  */

  11. package org.eclipse.jgit.patch;

  13. import static org.eclipse.jgit.util.RawParseUtils.nextLF;
  14. import static org.eclipse.jgit.util.RawParseUtils.parseBase10;

  16. import java.io.IOException;
  17. import java.io.OutputStream;
  18. import java.text.MessageFormat;

  20. import org.eclipse.jgit.internal.JGitText;
  21. import org.eclipse.jgit.lib.AbbreviatedObjectId;
  22. import org.eclipse.jgit.util.MutableInteger;

  24. /**
  25.  * Hunk header for a hunk appearing in a "diff --cc" style patch.
  26.  */
  27. public class CombinedHunkHeader extends HunkHeader {
  28.     private abstract static class CombinedOldImage extends OldImage {
  29.         int nContext;
  30.     }

  32.     private CombinedOldImage[] old;

  34.     CombinedHunkHeader(CombinedFileHeader fh, int offset) {
  35.         super(fh, offset, null);
  36.         old = new CombinedOldImage[fh.getParentCount()];
  37.         for (int i = 0; i < old.length; i++) {
  38.             final int imagePos = i;
  39.             old[i] = new CombinedOldImage() {
  40.                 @Override
  41.                 public AbbreviatedObjectId getId() {
  42.                     return fh.getOldId(imagePos);
  43.                 }
  44.             };
  45.         }
  46.     }

  48.     /** {@inheritDoc} */
  49.     @Override
  50.     public CombinedFileHeader getFileHeader() {
  51.         return (CombinedFileHeader) super.getFileHeader();
  52.     }

  54.     /** {@inheritDoc} */
  55.     @Override
  56.     public OldImage getOldImage() {
  57.         return getOldImage(0);
  58.     }

  60.     /**
  61.      * Get the OldImage data related to the nth ancestor
  62.      *
  63.      * @param nthParent
  64.      *            the ancestor to get the old image data of
  65.      * @return image data of the requested ancestor.
  66.      */
  67.     public OldImage getOldImage(int nthParent) {
  68.         return old[nthParent];
  69.     }

  71.     @Override
  72.     void parseHeader() {
  73.         // Parse "@@@ -55,12 -163,13 +163,15 @@@ protected boolean"
  74.         //
  75.         final byte[] buf = file.buf;
  76.         final MutableInteger ptr = new MutableInteger();
  77.         ptr.value = nextLF(buf, startOffset, ' ');

  79.         for (CombinedOldImage o : old) {
  80.             o.startLine = -parseBase10(buf, ptr.value, ptr);
  81.             if (buf[ptr.value] == ',') {
  82.                 o.lineCount = parseBase10(buf, ptr.value + 1, ptr);
  83.             } else {
  84.                 o.lineCount = 1;
  85.             }
  86.         }

  88.         newStartLine = parseBase10(buf, ptr.value + 1, ptr);
  89.         if (buf[ptr.value] == ',')
  90.             newLineCount = parseBase10(buf, ptr.value + 1, ptr);
  91.         else
  92.             newLineCount = 1;
  93.     }

  95.     @Override
  96.     int parseBody(Patch script, int end) {
  97.         final byte[] buf = file.buf;
  98.         int c = nextLF(buf, startOffset);

  100.         for (CombinedOldImage o : old) {
  101.             o.nDeleted = 0;
  102.             o.nAdded = 0;
  103.             o.nContext = 0;
  104.         }
  105.         nContext = 0;
  106.         int nAdded = 0;

  108.         SCAN: for (int eol; c < end; c = eol) {
  109.             eol = nextLF(buf, c);

  111.             if (eol - c < old.length + 1) {
  112.                 // Line isn't long enough to mention the state of each
  113.                 // ancestor. It must be the end of the hunk.
  114.                 break SCAN;
  115.             }

  117.             switch (buf[c]) {
  118.             case ' ':
  119.             case '-':
  120.             case '+':
  121.                 break;

  123.             default:
  124.                 // Line can't possibly be part of this hunk; the first
  125.                 // ancestor information isn't recognizable.
  126.                 //
  127.                 break SCAN;
  128.             }

  130.             int localcontext = 0;
  131.             for (int ancestor = 0; ancestor < old.length; ancestor++) {
  132.                 switch (buf[c + ancestor]) {
  133.                 case ' ':
  134.                     localcontext++;
  135.                     old[ancestor].nContext++;
  136.                     continue;

  138.                 case '-':
  139.                     old[ancestor].nDeleted++;
  140.                     continue;

  142.                 case '+':
  143.                     old[ancestor].nAdded++;
  144.                     nAdded++;
  145.                     continue;

  147.                 default:
  148.                     break SCAN;
  149.                 }
  150.             }
  151.             if (localcontext == old.length)
  152.                 nContext++;
  153.         }

  155.         for (int ancestor = 0; ancestor < old.length; ancestor++) {
  156.             final CombinedOldImage o = old[ancestor];
  157.             final int cmp = o.nContext + o.nDeleted;
  158.             if (cmp < o.lineCount) {
  159.                 final int missingCnt = o.lineCount - cmp;
  160.                 script.error(buf, startOffset, MessageFormat.format(
  161.                         JGitText.get().truncatedHunkLinesMissingForAncestor,
  162.                         Integer.valueOf(missingCnt),
  163.                         Integer.valueOf(ancestor + 1)));
  164.             }
  165.         }

  167.         if (nContext + nAdded < newLineCount) {
  168.             final int missingCount = newLineCount - (nContext + nAdded);
  169.             script.error(buf, startOffset, MessageFormat.format(
  170.                     JGitText.get().truncatedHunkNewLinesMissing,
  171.                     Integer.valueOf(missingCount)));
  172.         }

  174.         return c;
  175.     }

  177.     @Override
  178.     void extractFileLines(OutputStream[] out) throws IOException {
  179.         final byte[] buf = file.buf;
  180.         int ptr = startOffset;
  181.         int eol = nextLF(buf, ptr);
  182.         if (endOffset <= eol)
  183.             return;

  185.         // Treat the hunk header as though it were from the ancestor,
  186.         // as it may have a function header appearing after it which
  187.         // was copied out of the ancestor file.
  188.         //
  189.         out[0].write(buf, ptr, eol - ptr);

  191.         SCAN: for (ptr = eol; ptr < endOffset; ptr = eol) {
  192.             eol = nextLF(buf, ptr);

  194.             if (eol - ptr < old.length + 1) {
  195.                 // Line isn't long enough to mention the state of each
  196.                 // ancestor. It must be the end of the hunk.
  197.                 break SCAN;
  198.             }

  200.             switch (buf[ptr]) {
  201.             case ' ':
  202.             case '-':
  203.             case '+':
  204.                 break;

  206.             default:
  207.                 // Line can't possibly be part of this hunk; the first
  208.                 // ancestor information isn't recognizable.
  209.                 //
  210.                 break SCAN;
  211.             }

  213.             int delcnt = 0;
  214.             for (int ancestor = 0; ancestor < old.length; ancestor++) {
  215.                 switch (buf[ptr + ancestor]) {
  216.                 case '-':
  217.                     delcnt++;
  218.                     out[ancestor].write(buf, ptr, eol - ptr);
  219.                     continue;

  221.                 case ' ':
  222.                     out[ancestor].write(buf, ptr, eol - ptr);
  223.                     continue;

  225.                 case '+':
  226.                     continue;

  228.                 default:
  229.                     break SCAN;
  230.                 }
  231.             }
  232.             if (delcnt < old.length) {
  233.                 // This line appears in the new file if it wasn't deleted
  234.                 // relative to all ancestors.
  235.                 //
  236.                 out[old.length].write(buf, ptr, eol - ptr);
  237.             }
  238.         }
  239.     }

  241.     @Override
  242.     void extractFileLines(final StringBuilder sb, final String[] text,
  243.             final int[] offsets) {
  244.         final byte[] buf = file.buf;
  245.         int ptr = startOffset;
  246.         int eol = nextLF(buf, ptr);
  247.         if (endOffset <= eol)
  248.             return;
  249.         copyLine(sb, text, offsets, 0);
  250.         SCAN: for (ptr = eol; ptr < endOffset; ptr = eol) {
  251.             eol = nextLF(buf, ptr);

  253.             if (eol - ptr < old.length + 1) {
  254.                 // Line isn't long enough to mention the state of each
  255.                 // ancestor. It must be the end of the hunk.
  256.                 break SCAN;
  257.             }

  259.             switch (buf[ptr]) {
  260.             case ' ':
  261.             case '-':
  262.             case '+':
  263.                 break;

  265.             default:
  266.                 // Line can't possibly be part of this hunk; the first
  267.                 // ancestor information isn't recognizable.
  268.                 //
  269.                 break SCAN;
  270.             }

  272.             boolean copied = false;
  273.             for (int ancestor = 0; ancestor < old.length; ancestor++) {
  274.                 switch (buf[ptr + ancestor]) {
  275.                 case ' ':
  276.                 case '-':
  277.                     if (copied)
  278.                         skipLine(text, offsets, ancestor);
  279.                     else {
  280.                         copyLine(sb, text, offsets, ancestor);
  281.                         copied = true;
  282.                     }
  283.                     continue;

  285.                 case '+':
  286.                     continue;

  288.                 default:
  289.                     break SCAN;
  290.                 }
  291.             }
  292.             if (!copied) {
  293.                 // If none of the ancestors caused the copy then this line
  294.                 // must be new across the board, so it only appears in the
  295.                 // text of the new file.
  296.                 //
  297.                 copyLine(sb, text, offsets, old.length);
  298.             }
  299.         }
  300.     }
  301. }
Created with JaCoCo 0.8.7.202105040129