added a buffer for unfinished lines during progress bar printing. the lines will be completed by the next print, or way at the end when all progress bars are done.

src/org/rascalmpl/repl/TerminalProgressBarMonitor.java

@@ -10,6 +10,7 @@
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -42,7 +43,7 @@
      * Since there are generally very few threads a simple list beats a hash-map in terms
      * of memory allocation and possibly also lookup efficiency.
      */
     private List<UnfinishedLine> unfinishedLines = new ArrayList<>(3);
 
     /**
      * This writer is there to help with the encoding to what the terminal needs. It writes directly to the
@@ -117,93 +118,86 @@
         }  
     }
 
-    private class UnfinishedLine {
+    private static class UnfinishedLine {
         final long threadId;
-        int curCapacity = 512;
-        byte[] buffer = new byte[curCapacity];
-        int curEnd = 0;
-        int lastNewLine = 0;
+        private int curCapacity = 512;
+        private byte[] buffer = new byte[curCapacity];
+        private int curEnd = 0;
 
         public UnfinishedLine() {
             this.threadId = Thread.currentThread().getId();
         }
 
         /**
          * Adding input combines previously unfinished sentences with possible
-         * new sentences. A number of cases come together here that otherwise
-         * should be diligently separated. 
-         * 
-         *   - An unfinished line can already exist or not
-         *   - The new input can contain newlines or not
-         *   - The new input can end with a newline character or not
-         * 
-         * By concatenating the previous unfinished line with the new input
-         * all we have to do now is figure out where the last newline character is.
+         * new (unfinished) sentences. 
          * 
+         * The resulting buffer nevers contain any newline character.
          */
-        private void add(byte[] newInput, int offset, int len) {
+        private void store(byte[] newInput, int offset, int len) {
             // first ensure capacity of the array
             if (curEnd + len >= curCapacity) {
-                var oldCapacity = curCapacity;
-                curCapacity *= 2; // this should not happen to often. we're talking a few lines of text.
-                byte[] tmp = new byte[curCapacity];
-                System.arraycopy(buffer, 0, tmp, 0, oldCapacity);
-                buffer = tmp;
+                curCapacity *= 2; 
+                buffer = Arrays.copyOf(buffer, curCapacity);
             }
 
             System.arraycopy(newInput, offset, buffer, curEnd, len);
             curEnd += len;
-            lastNewLine = startOfLastLine();
         }
 
         public void write(byte[] n, OutputStream out) throws IOException {
-            add(n, 0, n.length);
-            flushToLastLine(out);
+            write(n, 0, n.length, out);
         }
 
+        /**
+         * Main workhorse looks for newline characters in the new input.
+         *  - if there are newlines, than whatever is in the buffer can be flushed.
+         *  - all the characters up to the last new new line are flushed immediately.
+         *  - all the new characters after the last newline are buffered.
+         */
         public void write(byte[] n, int offset, int len, OutputStream out) throws IOException {
-            add(n, offset, len);
-            flushToLastLine(out);
-        }
-
-        private void flushToLastLine(OutputStream out) throws IOException {
-            if (lastNewLine != -1) {
-                // write everything out (except the last unfinished line), but including the last newline
-                out.write(buffer, 0, lastNewLine + 1);
-
-                if (lastNewLine + 1 == curEnd) {
-                    // nothing left
-                    curEnd = 0;
-                    lastNewLine = -1;
-                }
-                else {
-                    // copy the last line that does not end with a newline
-                    curEnd -= lastNewLine;
-                    System.arraycopy(buffer, lastNewLine + 1, buffer, 0, curEnd);
-                    lastNewLine = -1; // no newline anymore
-                }
-            }
+            int lastNL = startOfLastLine(n, offset, len);
 
-            // otherwise we wait until the next input comes to be able to complete a line.
+            if (lastNL == -1) {
+                store(n, offset, len);
+            }
+            else {
+                flush(out);
+                out.write(n, offset, lastNL + 1);
+                store(n, offset, lastNL - offset);
+            }
         }
 
-        public void writeLeftOvers(OutputStream out) throws IOException {
+        /**
+         * This empties the current buffer onto the stream,
+         * and resets the cursor.
+         */
+        private void flush(OutputStream out) throws IOException {
             if (curEnd != 0) {
                 out.write(buffer, 0, curEnd);
-                out.write('\n');
                 curEnd = 0;
-                lastNewLine = -1;
+            }
+        }
+
+        /**
+         * Prints whatever is the last line in the buffer,
+         * and adds a newline.
+         */
+        public void flushLastLine(OutputStream out) throws IOException {
+            if (curEnd != 0) {
+                flush(out);
+                out.write('\n');
             }
         }
 
-        private int startOfLastLine() {
-            for (int i = curEnd - 1; i >= 0; i--) {
+        private int startOfLastLine(byte[] buffer, int offset, int len) {
+            for (int i = offset + len - 1; i >= 0; i--) {
                 if (buffer[i] == '\n') {
                     return i;
                 }
             }
 
             return -1;
         }
     }
 
@@ -332,7 +326,7 @@
                 + " "
                 ;
 
             writer.println(line); // note this puts us one line down
         }
 
         private String threadLabel() {
@@ -495,18 +489,18 @@
     }
 
     private UnfinishedLine findUnfinishedLine() {
         UnfinishedLine before = unfinishedLines.stream()
             .filter(l -> l.threadId == Thread.currentThread().getId())
             .findAny()
             .orElse(null);
 
         if (before == null) {
             UnfinishedLine l = new UnfinishedLine();
             unfinishedLines.add(l);
             before = l;
         }
 
         return before;
     }
 
     @Override
@@ -606,7 +600,7 @@
         if (!bars.isEmpty()) {
             eraseBars();
 
             findUnfinishedLine().write(b, out);
 
             printBars();
         }
@@ -624,7 +618,7 @@
     public synchronized void write(byte[] b, int off, int len) throws IOException {
         if (!bars.isEmpty()) {
             eraseBars();
             findUnfinishedLine().write(b, off, len, out);
             printBars();
         }
         else {
@@ -641,7 +635,7 @@
     public synchronized void write(int b) throws IOException {
         if (!bars.isEmpty()) {
             eraseBars();
             findUnfinishedLine().write(new byte[] { (byte) b }, out);
             printBars();
         }
         else {
@@ -662,12 +656,12 @@
         bars.clear();
         for (UnfinishedLine l : unfinishedLines) {
             try {
-                l.writeLeftOvers(out);
+                l.flushLastLine(out);
             }
             catch (IOException e) {
                 // might happen if the terminal crashes before we stop running 
             }
         }
         writer.write(ANSI.showCursor());
         writer.flush();
     }