diff --git a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/console/IOConsoleTests.java b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/console/IOConsoleTests.java
index e244d2f..eb0cb0a 100644
--- a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/console/IOConsoleTests.java
+++ b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/console/IOConsoleTests.java
@@ -382,6 +382,160 @@
 	}
 
 	/**
+	 * Test enabling/disabling control character interpretation.
+	 */
+	public void testControlCharacterSettings() throws Exception {
+		final IOConsoleTestUtil c = getTestUtil("Test options");
+
+		c.getConsole().setHandleControlCharacters(false);
+		c.getConsole().setCarriageReturnAsControlCharacter(false);
+		c.write("\r..");
+		assertEquals("Wrong number of lines.", 2, c.getDocument().getNumberOfLines());
+
+		c.getConsole().setCarriageReturnAsControlCharacter(true);
+		c.write("\r..");
+		assertEquals("Wrong number of lines.", 3, c.getDocument().getNumberOfLines());
+
+		c.getConsole().setHandleControlCharacters(true);
+		c.getConsole().setCarriageReturnAsControlCharacter(false);
+		c.write("\r..");
+		assertEquals("Wrong number of lines.", 4, c.getDocument().getNumberOfLines());
+
+		c.getConsole().setCarriageReturnAsControlCharacter(true);
+		c.write("\r..");
+		assertEquals("Wrong number of lines.", 4, c.getDocument().getNumberOfLines());
+
+		closeConsole(c);
+		assertEquals("Test triggered errors in IOConsole.", 0, loggedErrors.get());
+	}
+
+	/**
+	 * Test handling of <code>\b</code>.
+	 */
+	public void testBackspaceControlCharacter() throws Exception {
+		final IOConsoleTestUtil c = getTestUtil("Test \\b");
+		c.getConsole().setCarriageReturnAsControlCharacter(false);
+		c.getConsole().setHandleControlCharacters(true);
+		try (IOConsoleOutputStream err = c.getConsole().newOutputStream()) {
+			// test simple backspace cases
+			c.write("\b").write("|").verifyContent("|").verifyPartitions();
+			c.writeFast("\b").write("/").verifyContent("/").verifyPartitions();
+			c.writeFast("\b\b\b").write("-\b").verifyContent("-").verifyPartitions();
+			c.writeFast("\b1\b2\b3\b").write("\\").verifyContent("\\").verifyPartitions();
+
+			// test existing output is overwritten independent from stream
+			c.clear();
+			c.writeFast("out").write("err", err).verifyContent("outerr").verifyPartitions(2);
+			c.writeFast("\b\b\b\b\b\b\b\b\b\b\b\b\b");
+			c.writeFast("err", err).write("out").verifyContent("errout").verifyPartitions(2);
+			c.writeFast("\b\b\b\b\b\b\b\b\b\b\b\b\b");
+			c.writeFast("12", err).writeFast("345").write("6789", err).verifyContent("123456789").verifyPartitions(3);
+
+			// test backspace stops at line start
+			c.clear();
+			c.writeFast("First line\n").writeFast("\b\b", err).writeFast("Zecond line");
+			c.writeFast("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
+			c.write("S", err).verifyContentByLine("First line", 0).verifyContentByLine("Second line", 1).verifyPartitions(2);
+
+			// test in combination with input partitions
+			c.clear();
+			c.writeAndVerify("out").insertTyping("input").writeAndVerify("err", err).verifyContent("outinputerr").verifyPartitions(3);
+			c.setCaretOffset(6).backspace().backspace().writeAndVerify("~~~").verifyContentByOffset("~~~", -3).verifyPartitions(3);
+			c.verifyContent("outiuterr~~~");
+			c.writeFast("\b\b\b\b\b\b\b\b\b\b\b\b\b");
+			c.write("output").verifyContent("outiutput~~~").verifyPartitions(3);
+			c.setCaretOffset(4).insertTyping("np").verifyContent("outinputput~~~").verifyPartitions(3);
+			c.write("+++++", err).verifyContent("outinputput+++++").verifyPartitions(3);
+			c.writeFast(String.join("", Collections.nCopies(11, "\b")));
+			c.write("err", err).verifyContent("errinputput+++++").verifyPartitions(3);
+
+			c.clear();
+			c.writeAndVerify("ooooo").insertTyping("iii").write("eeee", err).moveCaretToEnd().insertTyping("i").write("oo");
+			c.verifyContent("oooooiiieeeeioo").verifyPartitions(3);
+			c.writeFast(String.join("", Collections.nCopies(7, "\b")));
+			c.write("xx").verifyContent("ooooxiiixeeeioo").verifyPartitions(3);
+
+			c.clear();
+			c.insert("iiii").writeFast("\b").write("o").verifyContent("iiiio").verifyPartitions(2);
+			c.write("\b\bee", err).verifyContentByOffset("iiiiee", 0).verifyPartitions(2);
+			c.writeFast("\b\b\b\b\b\b\b\b", err).write("o").verifyContent("iiiioe").verifyPartitions(3);
+
+			// test if backspace overruns line breaks introduced by input
+			// (at the moment it should overrun those line breaks)
+			c.clear();
+			c.writeAndVerify("1", err).insertTyping("input").enter().write("2");
+			c.verifyContentByLine("1input", 0).verifyContentByLine("2", 1).verifyPartitions(3);
+			c.writeFast("\b\b\b\b\b\b\b\b\b\b\b\b\b", err);
+			c.write("???").verifyContentByLine("?input", 0).verifyContentByLine("??", 1).verifyPartitions(3);
+			c.writeFast("\b\b").writeFast("\b", err).write("><~");
+			c.verifyContentByLine(">input", 0).verifyContentByLine("<~", 1).verifyPartitions(3);
+
+			// test output cursor moves according to changed input
+			c.clear();
+			c.writeAndVerify("abc", err).insert("<>").write("def").verifyContent("abc<>def").verifyPartitions(3);
+			c.write("\b\b").setCaretOffset(4).insertTypingAndVerify("-=-").verifyContent("abc<-=->def").verifyPartitions(3);
+			c.moveCaret(-1).backspace().verifyContent("abc<-->def").verifyPartitions(3);
+			c.write("e\b\b\b\b", err).insertTyping("++").verifyContent("abc<-++->def").verifyPartitions(3);
+			c.select(0, c.getDocument().getLength()).backspace().write("b").verifyContent("abcdef").verifyPartitions(3);
+
+			// break output line
+			// NOTE: this may not be the desired behavior
+			c.clear();
+			c.writeFast("1.2.").writeFast("\b\b").write("\n");
+			c.verifyContentByLine("1.", 0).verifyContentByLine(".", 1).verifyPartitions();
+			c.writeFast("\b\b\b\b").write("2.");
+			c.verifyContentByLine("1.", 0).verifyContentByLine("2.", 1).verifyPartitions();
+		}
+		closeConsole(c);
+		assertEquals("Test triggered errors in IOConsole.", 0, loggedErrors.get());
+	}
+
+	/**
+	 * Test handling of <code>\r</code>.
+	 */
+	public void testCarriageReturnControlCharacter() throws Exception {
+		final IOConsoleTestUtil c = getTestUtil("Test \\r");
+		c.getConsole().setCarriageReturnAsControlCharacter(true);
+		c.getConsole().setHandleControlCharacters(true);
+		try (IOConsoleOutputStream err = c.getConsole().newOutputStream()) {
+			// test simple carriage return cases
+			c.write("\r");
+			assertEquals("Wrong number of lines.", 1, c.getDocument().getNumberOfLines());
+			c.writeFast("bad", err).write("\rgood").verifyContent("good").verifyPartitions(1);
+			assertEquals("Wrong number of lines.", 1, c.getDocument().getNumberOfLines());
+
+			// test carriage return stops at line start
+			c.clear();
+			c.writeFast("First line\r\n").write("Zecond line", err);
+			c.verifyContentByLine("First line", 0).verifyContentByLine("Zecond line", 1).verifyPartitions(2);
+			assertEquals("Wrong number of lines.", 2, c.getDocument().getNumberOfLines());
+			c.writeFast("\r").write("3.    ").verifyContentByLine("3.     line", 1).verifyPartitions(2);
+			assertEquals("Wrong number of lines.", 2, c.getDocument().getNumberOfLines());
+			c.writeFast("\r\r\r", err).write("Second").verifyContentByLine("Second line", 1).verifyPartitions(2);
+			assertEquals("Wrong number of lines.", 2, c.getDocument().getNumberOfLines());
+
+			// test carriage return with input partitions
+			c.clear();
+			c.insertTypingAndVerify("input").writeFast("out\r").write("err", err);
+			c.verifyContent("inputerr").verifyPartitions(2);
+			c.enter().write("\rout").verifyContentByLine("inputout", 0).verifyPartitions(2);
+			c.write("err", err).verifyContentByLine("err", 1).verifyPartitions(3);
+			c.write("\roooooo").verifyContentByLine("inputooo", 0).verifyContentByLine("ooo", 1).verifyPartitions(2);
+
+			// test in combination with \r\n
+			c.clear();
+			c.write("\r\n");
+			assertEquals("Wrong number of lines.", 2, c.getDocument().getNumberOfLines());
+			c.writeFast("err", err).writeFast("\r\r\r\r\r\r\r\r\n\n").write("out");
+			assertEquals("Wrong number of lines.", 4, c.getDocument().getNumberOfLines());
+			c.verifyContentByLine("out", -1).verifyPartitions();
+			assertTrue("Line breaks did not overwrite text.", !c.getDocument().get().contains("err"));
+		}
+		closeConsole(c);
+		assertEquals("Test triggered errors in IOConsole.", 0, loggedErrors.get());
+	}
+
+	/**
 	 * Test larger number of partitions with pseudo random console content.
 	 */
 	public void testManyPartitions() throws IOException {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/DebugUIPreferenceInitializer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/DebugUIPreferenceInitializer.java
index 955bda6..3fb4c50 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/DebugUIPreferenceInitializer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/DebugUIPreferenceInitializer.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- *  Copyright (c) 2004, 2018 IBM Corporation and others.
+ *  Copyright (c) 2004, 2019 IBM Corporation and others.
  *
  *  This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License 2.0
@@ -80,6 +80,8 @@
 		prefs.setDefault(IDebugPreferenceConstants.CONSOLE_LOW_WATER_MARK, 80000);
 		prefs.setDefault(IDebugPreferenceConstants.CONSOLE_HIGH_WATER_MARK, 100000);
 		prefs.setDefault(IDebugPreferenceConstants.CONSOLE_TAB_WIDTH, 8);
+		prefs.setDefault(IDebugPreferenceConstants.CONSOLE_INTERPRET_CONTROL_CHARACTERS, false);
+		prefs.setDefault(IDebugPreferenceConstants.CONSOLE_INTERPRET_CR_AS_CONTROL_CHARACTER, true);
 
 		// console colors
 		setThemeBasedPreferences(prefs, false);
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/ConsolePreferencePage.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/ConsolePreferencePage.java
index 881290b..7789876 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/ConsolePreferencePage.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/ConsolePreferencePage.java
@@ -81,6 +81,9 @@
 	private ConsoleIntegerFieldEditor fTabSizeEditor;
 	private BooleanFieldEditor autoScrollLockEditor;
 
+	private BooleanFieldEditor2 fInterpretControlCharactersEditor;
+	private BooleanFieldEditor2 fInterpretCrAsControlCharacterEditor;
+
 	/**
 	 * Create the console page.
 	 */
@@ -157,6 +160,15 @@
 		addField(syserr);
 		addField(sysin);
 		addField(background);
+
+		fInterpretControlCharactersEditor = new BooleanFieldEditor2(IDebugPreferenceConstants.CONSOLE_INTERPRET_CONTROL_CHARACTERS, DebugPreferencesMessages.ConsolePreferencePage_Interpret_control_characters, SWT.NONE, getFieldEditorParent());
+		fInterpretCrAsControlCharacterEditor = new BooleanFieldEditor2(IDebugPreferenceConstants.CONSOLE_INTERPRET_CR_AS_CONTROL_CHARACTER, DebugPreferencesMessages.ConsolePreferencePage_Interpret_cr_as_control_character, SWT.NONE, getFieldEditorParent());
+
+		fInterpretControlCharactersEditor.getChangeControl(getFieldEditorParent()).addListener(SWT.Selection,
+				event -> updateInterpretCrAsControlCharacterEditor());
+
+		addField(fInterpretControlCharactersEditor);
+		addField(fInterpretCrAsControlCharacterEditor);
 	}
 
 	/**
@@ -186,6 +198,7 @@
 		updateWidthEditor();
 		updateAutoScrollLockEditor();
 		updateBufferSizeEditor();
+		updateInterpretCrAsControlCharacterEditor();
 	}
 
 	/**
@@ -216,6 +229,15 @@
 	}
 
 	/**
+	 * Update enablement of carriage return interpretation based on general control
+	 * character interpretation.
+	 */
+	protected void updateInterpretCrAsControlCharacterEditor() {
+		Button b = fInterpretControlCharactersEditor.getChangeControl(getFieldEditorParent());
+		fInterpretCrAsControlCharacterEditor.getChangeControl(getFieldEditorParent()).setEnabled(b.getSelection());
+	}
+
+	/**
 	 * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
 	 */
 	@Override
@@ -223,6 +245,7 @@
 		super.performDefaults();
 		updateWidthEditor();
 		updateBufferSizeEditor();
+		updateInterpretCrAsControlCharacterEditor();
 	}
 
 	protected boolean canClearErrorMessage() {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.java
index 41b5306..b741769 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- *  Copyright (c) 2000, 2018 IBM Corporation and others.
+ *  Copyright (c) 2000, 2019 IBM Corporation and others.
  *
  *  This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License 2.0
@@ -35,6 +35,8 @@
 	public static String ConsolePreferencePage_console_width;
 	public static String ConsolePreferencePage_12;
 	public static String ConsolePreferencePage_13;
+	public static String ConsolePreferencePage_Interpret_control_characters;
+	public static String ConsolePreferencePage_Interpret_cr_as_control_character;
 
 	public static String DebugPreferencePage_1;
 	public static String DebugPreferencePage_2;
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.properties b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.properties
index 36ddf27..c4cabbc 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.properties
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.properties
@@ -1,5 +1,5 @@
 ###############################################################################
-# Copyright (c) 2000, 2018 IBM Corporation and others.
+# Copyright (c) 2000, 2019 IBM Corporation and others.
 #
 # This program and the accompanying materials
 # are made available under the terms of the Eclipse Public License 2.0
@@ -28,6 +28,8 @@
 ConsolePreferencePage_12=Displayed &tab width:
 ConsolePreferencePage_13=Tab width must be between 1 and 100 inclusive.
 ConsolePreferencePage_11=Back&ground color:
+ConsolePreferencePage_Interpret_control_characters=Interpret ASCII &control characters
+ConsolePreferencePage_Interpret_cr_as_control_character=Interpret Carriage &Return (\\r) as control character 
 
 DebugPreferencePage_1=General Settings for Running and Debugging.
 DebugPreferencePage_2=Re&use editor when displaying source code
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/IDebugPreferenceConstants.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/IDebugPreferenceConstants.java
index 93d9c16..9b9355f 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/IDebugPreferenceConstants.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/IDebugPreferenceConstants.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2018 IBM Corporation and others.
+ * Copyright (c) 2000, 2019 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -91,7 +91,31 @@
 	 */
 	String CONSOLE_TAB_WIDTH= "Console.console_tab_width"; //$NON-NLS-1$
 
+	/**
+	 * (boolean) If <code>true</code> console will interpret ASCII control
+	 * characters like <code>\b</code> received from stdout or stderr (or any other
+	 * connected output stream).
+	 * <p>
+	 * If <code>false</code> control characters are appended to console like any
+	 * other character. Since they are usually not printable they may be invisible
+	 * or result in some Unicode default representation.
+	 * </p>
+	 */
+	String CONSOLE_INTERPRET_CONTROL_CHARACTERS = "Console.interpret_control_characters"; //$NON-NLS-1$
 
+	/**
+	 * (boolean) Only used if {@link #CONSOLE_INTERPRET_CONTROL_CHARACTERS} is
+	 * <code>true</code>.
+	 * <p>
+	 * If <code>true</code> carriage returns are handled with there usual control
+	 * character interpretation. (move output cursor to begin of line)
+	 * </p>
+	 * <p>
+	 * If <code>false</code> carriage returns are not handled special and may result
+	 * in line breaks since they are usually legal line delimiter.
+	 * </p>
+	 */
+	String CONSOLE_INTERPRET_CR_AS_CONTROL_CHARACTER = "Console.interpret_cr_as_control_characters"; //$NON-NLS-1$
 
 	/**
 	 * The orientation of the detail view in the VariablesView
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java
index bfb739a..4f510b2 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java
@@ -376,6 +376,10 @@
 			setFont(JFaceResources.getFont(IDebugUIConstants.PREF_CONSOLE_FONT));
 		} else if (property.equals(IDebugPreferenceConstants.CONSOLE_BAKGROUND_COLOR)) {
 			setBackground(DebugUIPlugin.getPreferenceColor(IDebugPreferenceConstants.CONSOLE_BAKGROUND_COLOR));
+		} else if (property.equals(IDebugPreferenceConstants.CONSOLE_INTERPRET_CONTROL_CHARACTERS)) {
+			setHandleControlCharacters(store.getBoolean(IDebugPreferenceConstants.CONSOLE_INTERPRET_CONTROL_CHARACTERS));
+		} else if (property.equals(IDebugPreferenceConstants.CONSOLE_INTERPRET_CR_AS_CONTROL_CHARACTER)) {
+			setCarriageReturnAsControlCharacter(store.getBoolean(IDebugPreferenceConstants.CONSOLE_INTERPRET_CR_AS_CONTROL_CHARACTER));
 		}
 	}
 
@@ -485,6 +489,9 @@
 			setWaterMarks(lowWater, highWater);
 		}
 
+		setHandleControlCharacters(store.getBoolean(IDebugPreferenceConstants.CONSOLE_INTERPRET_CONTROL_CHARACTERS));
+		setCarriageReturnAsControlCharacter(store.getBoolean(IDebugPreferenceConstants.CONSOLE_INTERPRET_CR_AS_CONTROL_CHARACTER));
+
 		DebugUIPlugin.getStandardDisplay().asyncExec(() -> {
 			setFont(JFaceResources.getFont(IDebugUIConstants.PREF_CONSOLE_FONT));
 			setBackground(DebugUIPlugin.getPreferenceColor(IDebugPreferenceConstants.CONSOLE_BAKGROUND_COLOR));
diff --git a/org.eclipse.ui.console/src/org/eclipse/ui/console/IOConsole.java b/org.eclipse.ui.console/src/org/eclipse/ui/console/IOConsole.java
index 77e6172..8437172 100644
--- a/org.eclipse.ui.console/src/org/eclipse/ui/console/IOConsole.java
+++ b/org.eclipse.ui.console/src/org/eclipse/ui/console/IOConsole.java
@@ -347,4 +347,59 @@
 		return this.charset;
 	}
 
+	/**
+	 * Check if console currently interprets ASCII control characters.
+	 *
+	 * @return <code>true</code> if console interprets ASCII control characters
+	 * @since 3.9
+	 */
+	public boolean isHandleControlCharacters() {
+		return partitioner.isHandleControlCharacters();
+	}
+
+	/**
+	 * Enable or disable interpretation of ASCII control characters like backspace
+	 * (<code>\b</code>).
+	 *
+	 * @param handleControlCharacters interpret control characters if
+	 *                                <code>true</code>
+	 * @since 3.9
+	 */
+	public void setHandleControlCharacters(boolean handleControlCharacters) {
+		partitioner.setHandleControlCharacters(handleControlCharacters);
+	}
+
+	/**
+	 * Check if carriage returns (<code>\r</code>) in console output are interpreted
+	 * as control characters. They are also not interpreted if general control
+	 * character handling is disabled.
+	 *
+	 * @return if <code>true</code> carriage returns are interpreted as control
+	 *         characters.
+	 * @see #isHandleControlCharacters()
+	 * @since 3.9
+	 */
+	public boolean isCarriageReturnAsControlCharacter() {
+		return partitioner.isCarriageReturnAsControlCharacter();
+	}
+
+	/**
+	 * If control characters in console output are interpreted by this console
+	 * carriage returns (<code>\r</code>) are either ignored (<code>false</code>)
+	 * and usually handled as line break by connected console document or if
+	 * <code>true</code> interpreted with there control character meaning.
+	 * <p>
+	 * Note: this option has no effect if control character interpretation is
+	 * disabled in general.
+	 * </p>
+	 *
+	 * @param carriageReturnAsControlCharacter set <code>false</code> to exclude
+	 *                                         carriage return from control
+	 *                                         character interpretation
+	 * @see #setHandleControlCharacters(boolean)
+	 * @since 3.9
+	 */
+	public void setCarriageReturnAsControlCharacter(boolean carriageReturnAsControlCharacter) {
+		partitioner.setCarriageReturnAsControlCharacter(carriageReturnAsControlCharacter);
+	}
 }
diff --git a/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/IOConsolePartitioner.java b/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/IOConsolePartitioner.java
index 477e7a1..d2f6fbc 100644
--- a/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/IOConsolePartitioner.java
+++ b/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/IOConsolePartitioner.java
@@ -15,6 +15,7 @@
  *                          Bug 548356: fixed user input handling
  *                          Bug 550618: getStyleRanges produced invalid overlapping styles
  *                          Bug 550621: Implementation of IConsoleDocumentPartitionerExtension
+ *                          Bug 76936:  Support interpretation of \b and \r in console output
  *******************************************************************************/
 package org.eclipse.ui.internal.console;
 
@@ -25,6 +26,8 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -89,6 +92,17 @@
 	 */
 	private static final Comparator<IRegion> CMP_REGION_BY_OFFSET = Comparator.comparing(IRegion::getOffset);
 
+	/**
+	 * Pattern used to find supported ASCII control characters <b>except</b>
+	 * carriage return.
+	 */
+	private static final String CONTROL_CHARACTERS_PATTERN_STR = "(?:\b+)"; //$NON-NLS-1$
+	/**
+	 * Pattern used to find supported ASCII control characters <b>including</b>
+	 * carriage return.
+	 */
+	private static final String CONTROL_CHARACTERS_WITH_CR_PATTERN_STR = "(?:\b+|\r+(?!\n))"; //$NON-NLS-1$
+
 	/** The connected {@link IDocument} this partitioner manages. */
 	private IDocument document;
 	/**
@@ -130,6 +144,10 @@
 	 * length trimming is scheduled. Trimming is disabled if value is negative.
 	 */
 	private int highWaterMark = -1;
+	/**
+	 * The low mark for console content trimming. If trim is performed approximate
+	 * this many characters are remain in console.
+	 */
 	private int lowWaterMark = -1;
 
 	/** The partitioned {@link IOConsole}. */
@@ -137,6 +155,21 @@
 
 	/** Set after console signaled that all streams are closed. */
 	private volatile boolean streamsClosed;
+	/**
+	 * Active pattern to search for supported control characters. If
+	 * <code>null</code> control characters are treated as any other characters.
+	 */
+	private Pattern controlCharacterPattern = null;
+	/**
+	 * Whether <code>\r</code> is interpreted as control characters
+	 * (<code>true</code>) or not in console output. If <code>false</code> they are
+	 * probably handled as newline.
+	 */
+	private boolean carriageReturnAsControlCharacter = true;
+	/**
+	 * Offset where next output is written to console.
+	 */
+	private int outputOffset = 0;
 
 	/**
 	 * Create new partitioner for an {@link IOConsole}.
@@ -421,6 +454,7 @@
 				synchronized (partitions) {
 					partitions.clear();
 					inputPartitions.clear();
+					outputOffset = 0;
 				}
 				return new Region(0, 0);
 			}
@@ -428,6 +462,12 @@
 			synchronized (partitions) {
 				switch (updateType) {
 				case INPUT:
+					if (event.getOffset() <= outputOffset) { // move output offset if necessary
+						outputOffset -= Math.min(event.getLength(), outputOffset - event.getOffset());
+						if (event.getText() != null) {
+							outputOffset += event.getText().length();
+						}
+					}
 					return applyUserInput(event);
 
 				// update and trim jobs are triggered by this partitioner and all partitioning
@@ -740,28 +780,325 @@
 			pendingPartitions.notifyAll();
 		}
 		synchronized (partitions) {
-			final StringBuilder addedContent = new StringBuilder(size);
-			IOConsolePartition lastPartition = getPartitionByIndex(partitions.size() - 1);
-			int nextOffset = document.getLength();
-			for (PendingPartition pendingPartition : pendingCopy) {
-				if (lastPartition == null || lastPartition.getOutputStream() != pendingPartition.stream) {
-					lastPartition = new IOConsolePartition(nextOffset, pendingPartition.stream);
-					partitions.add(lastPartition);
+			if (isHandleControlCharacters()) {
+				applyStreamOutput(pendingCopy, size);
+			} else {
+				// Old implementation of output appending. The control character aware variant
+				// {@link #applyStreamOutput(List, int)} should do exactly the same if control
+				// character processing is disabled but since there is not so much time for
+				// testing in current development cycle the old implementation is used to
+				// process output when control character interpretation is disabled.
+				// TODO remove in next development cycle
+				final StringBuilder addedContent = new StringBuilder(size);
+				IOConsolePartition lastPartition = getPartitionByIndex(partitions.size() - 1);
+				int nextOffset = document.getLength();
+				for (PendingPartition pendingPartition : pendingCopy) {
+					if (lastPartition == null || lastPartition.getOutputStream() != pendingPartition.stream) {
+						lastPartition = new IOConsolePartition(nextOffset, pendingPartition.stream);
+						partitions.add(lastPartition);
+					}
+					final int pendingLength = pendingPartition.text.length();
+					lastPartition.setLength(lastPartition.getLength() + pendingLength);
+					nextOffset += pendingLength;
+					addedContent.append(pendingPartition.text);
 				}
-				final int pendingLength = pendingPartition.text.length();
-				lastPartition.setLength(lastPartition.getLength() + pendingLength);
-				nextOffset += pendingLength;
-				addedContent.append(pendingPartition.text);
+				try {
+					updateType = DocUpdateType.OUTPUT;
+					document.replace(document.getLength(), 0, addedContent.toString());
+					outputOffset += addedContent.length();
+				} catch (BadLocationException e) {
+					log(e);
+				}
+			}
+		}
+		checkFinished();
+		checkBufferSize();
+	}
+
+	/**
+	 * Apply content collected in pending partitions to document and update
+	 * partitioning structure.
+	 * <p>
+	 * This method is also responsible to interpret control characters if enabled
+	 * (see {@link #isHandleControlCharacters()}).
+	 * </p>
+	 *
+	 * @param pendingCopy the pending partitions to process
+	 * @param sizeHint    a hint for expected content length to initialize buffer
+	 *                    size. Does not have to be exact as long as it is not
+	 *                    negative.
+	 */
+	private void applyStreamOutput(List<PendingPartition> pendingCopy, int sizeHint) {
+		// local reference to get consistent parsing without blocking pattern changes
+		final Pattern controlPattern = controlCharacterPattern;
+		// Variables to collect required data to reduce number of document updates. The
+		// partitioning must be updated in smaller iterations as the actual document
+		// content. E.g. pending partitions are distinct on source output stream
+		// resulting in multiple partitions but if all the content is appended to the
+		// document there is only one update required to add the actual content.
+		int nextWriteOffset = outputOffset;
+		final StringBuilder content = new StringBuilder(sizeHint);
+		int replaceLength = 0;
+		// the partition which contains the current output offset
+		IOConsolePartition atOutputPartition = null;
+		// the index of atOutputPartition in the partitions list
+		int atOutputPartitionIndex = -1;
+
+		for (PendingPartition pending : pendingCopy) {
+			// create matcher to find control characters in pending content (if enabled)
+			final Matcher controlCharacterMatcher = controlPattern != null ? controlPattern.matcher(pending.text)
+					: null;
+
+			for (int textOffset = 0; textOffset < pending.text.length();) {
+				// Process pending content in chunks.
+				// Processing is primary split on control characters since there interpretation
+				// is easier if all content changes before are already applied.
+				// Additional processing splits may result while overwriting existing output and
+				// overwrite overlaps partitions.
+				final boolean foundControlCharacter;
+				final int partEnd;
+				if (controlCharacterMatcher != null && controlCharacterMatcher.find()) {
+					if (ASSERT) {
+						// check used pattern. Assert it matches only sequences of same characters.
+						final String match = controlCharacterMatcher.group();
+						Assert.isTrue(match.length() > 0);
+						final char matchedChar = match.charAt(0);
+						for (char c : match.toCharArray()) {
+							Assert.isTrue(c == matchedChar);
+						}
+					}
+					partEnd = controlCharacterMatcher.start();
+					foundControlCharacter = true;
+				} else {
+					partEnd = pending.text.length();
+					foundControlCharacter = false;
+				}
+
+				while (textOffset < partEnd) {
+					// Process content part. This part never contains control characters.
+					// Processing may require multiple iterations if we overwrite existing content
+					// which consists of distinct partitions.
+
+					if (outputOffset >= document.getLength()) {
+						// content is appended to document end (the easy case)
+						if (atOutputPartition == null) {
+							// get the last existing partition to try to expand it
+							atOutputPartitionIndex = partitions.size() - 1;
+							atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+							if (ASSERT) {
+								Assert.isTrue(atOutputPartitionIndex == findPartitionCandidate(outputOffset - 1));
+							}
+						}
+						if (atOutputPartition == null || atOutputPartition.getOutputStream() != pending.stream) {
+							// no partitions yet or last partition is incompatible to reuse -> add new one
+							atOutputPartition = new IOConsolePartition(outputOffset, pending.stream);
+							partitions.add(atOutputPartition);
+							atOutputPartitionIndex = partitions.size() - 1;
+						}
+						final int appendedLength = partEnd - textOffset;
+						content.append(pending.text, textOffset, partEnd);
+						atOutputPartition.setLength(atOutputPartition.getLength() + appendedLength);
+						outputOffset += appendedLength;
+						textOffset = partEnd;
+					} else {
+						// content overwrites existing console content (the tricky case)
+						if (atOutputPartition == null) {
+							// find partition where output will overwrite or create one if unpartitioned
+							atOutputPartitionIndex = findPartitionCandidate(outputOffset);
+							atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+							if (atOutputPartition == null) {
+								atOutputPartition = new IOConsolePartition(outputOffset, pending.stream);
+								atOutputPartitionIndex++;
+								partitions.add(atOutputPartitionIndex, atOutputPartition);
+							}
+						}
+
+						// we do not overwrite input partitions at the moment so they need to be skipped
+						if (isInputPartition(atOutputPartition)) {
+							outputOffset = atOutputPartition.getOffset() + atOutputPartition.getLength();
+							atOutputPartitionIndex++;
+							atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+
+							// apply document changes collected until now
+							applyOutputToDocument(content.toString(), nextWriteOffset, replaceLength);
+							content.setLength(0);
+							replaceLength = 0;
+							nextWriteOffset = outputOffset;
+							continue; // to check if next selected partition is also input or appending now
+						}
+
+						// limit chunks to overwrite only one existing partition at a time
+						final int chunkLength = Math.min(partEnd - textOffset,
+								atOutputPartition.getLength() - (outputOffset - atOutputPartition.getOffset()));
+						Assert.isTrue(chunkLength > 0); // do not remove since it can prevent an infinity loop
+
+						if (atOutputPartition.getOutputStream() != pending.stream) {
+							// new output is from other stream then overwritten output
+
+							// Note: this implementation ignores the possibility to reuse the partition
+							// where the overwrite chunk ends and expand it towards replace begin since this
+							// makes things code much more complex. In some cases this may leads to
+							// consecutive partitions which could be merged to one partition. Merging is not
+							// implemented at the moment.
+
+							// in this part outputPartition is used to partition the new content
+							// and atOutputPartition points to the partition whose content is overwritten
+							// i.e. the new partition grows and the old one must shrink
+							IOConsolePartition outputPartition = null;
+							if (atOutputPartition.getOffset() == outputOffset) {
+								// try to expand the partition before our output offset
+								outputPartition = getPartitionByIndex(atOutputPartitionIndex - 1);
+							} else {
+								// overwrite starts inside existing incompatible partition
+								atOutputPartition = splitPartition(outputOffset);
+								atOutputPartitionIndex++;
+							}
+							if (outputPartition == null || outputPartition.getOutputStream() != pending.stream) {
+								outputPartition = new IOConsolePartition(outputOffset, pending.stream);
+								partitions.add(atOutputPartitionIndex, outputPartition);
+								atOutputPartitionIndex++;
+							}
+
+							// update partitioning of the overwritten chunk
+							outputPartition.setLength(outputPartition.getLength() + chunkLength);
+							atOutputPartition.setOffset(atOutputPartition.getOffset() + chunkLength);
+							atOutputPartition.setLength(atOutputPartition.getLength() - chunkLength);
+
+							if (atOutputPartition.getLength() == 0) {
+								// overwritten partition is now empty and must be be removed
+								partitions.remove(atOutputPartitionIndex);
+								atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+							}
+						}
+						content.append(pending.text, textOffset, textOffset + chunkLength);
+						replaceLength += chunkLength;
+						textOffset += chunkLength;
+						outputOffset += chunkLength;
+						if (atOutputPartition != null
+								&& outputOffset == atOutputPartition.getOffset() + atOutputPartition.getLength()) {
+							atOutputPartitionIndex++;
+							atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+						}
+					}
+				}
+				// finished processing of regular content before control characters
+				// now interpret control characters if any
+				if (controlCharacterMatcher != null && foundControlCharacter) {
+					// at first update console document since it is easier to interpret control
+					// characters on an up-to-date document and partitioning
+					applyOutputToDocument(content.toString(), nextWriteOffset, replaceLength);
+					content.setLength(0);
+					replaceLength = 0;
+
+					final String controlCharacterMatch = controlCharacterMatcher.group();
+					final char controlCharacter = controlCharacterMatch.charAt(0);
+					switch (controlCharacter) {
+					case '\b':
+						// move virtual output cursor one step back for each \b
+						// but stop at current line start and skip any input partitions
+						final int outputLineStartOffset = findOutputLineStartOffset(outputOffset);
+						int backStepCount = controlCharacterMatch.length();
+						if (partitions.size() == 0) {
+							outputOffset = 0;
+							break;
+						}
+						if (atOutputPartition == null) {
+							atOutputPartitionIndex = partitions.size() - 1;
+							atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+						}
+						while (backStepCount > 0 && outputOffset > outputLineStartOffset) {
+							if (atOutputPartition != null && isInputPartition(atOutputPartition)) {
+								do {
+									outputOffset = atOutputPartition.getOffset() - 1;
+									atOutputPartitionIndex--;
+									atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+								} while (atOutputPartition != null && isInputPartition(atOutputPartition));
+								backStepCount--;
+							}
+							if (atOutputPartition == null) {
+								outputOffset = 0;
+								break;
+							}
+							final int backSteps = Math.min(outputOffset - atOutputPartition.getOffset(), backStepCount);
+							outputOffset -= backSteps;
+							backStepCount -= backSteps;
+							atOutputPartitionIndex--;
+							atOutputPartition = getPartitionByIndex(atOutputPartitionIndex);
+						}
+						outputOffset = Math.max(outputOffset, outputLineStartOffset);
+						break;
+
+					case '\r':
+						// move virtual output cursor to start of output line
+						outputOffset = findOutputLineStartOffset(outputOffset);
+						atOutputPartitionIndex = -1;
+						atOutputPartition = null;
+						break;
+
+					default:
+						// should never happen as long as the used regex pattern is valid
+						log(IStatus.ERROR, "No implementation to handle control character 0x" //$NON-NLS-1$
+								+ Integer.toHexString(controlCharacter));
+						break;
+					}
+					nextWriteOffset = outputOffset;
+					textOffset = controlCharacterMatcher.end();
+				}
+			}
+		}
+		applyOutputToDocument(content.toString(), nextWriteOffset, replaceLength);
+	}
+
+	/**
+	 * Find offset of line start from given output offset. This method ignores line
+	 * breaks partitioned as input. I.e. it looks at the document as if it only
+	 * consist of the output parts.
+	 *
+	 * @param outOffset offset where output should be written
+	 * @return the start offset of line where output should be written
+	 */
+	private int findOutputLineStartOffset(int outOffset) {
+		int outputLineStartOffset = 0;
+		try {
+			for (int lineIndex = document.getLineOfOffset(outOffset); lineIndex >= 0; lineIndex--) {
+				outputLineStartOffset = document.getLineOffset(lineIndex);
+				final IOConsolePartition lineBreakPartition = getIOPartition(outputLineStartOffset - 1);
+				if (lineBreakPartition == null || !isInputPartition(lineBreakPartition)) {
+					break;
+				}
+			}
+		} catch (BadLocationException e) {
+			log(e);
+			outputLineStartOffset = 0;
+		}
+		if (ASSERT) {
+			Assert.isTrue(outputLineStartOffset <= outOffset);
+		}
+		return outputLineStartOffset;
+	}
+
+	/**
+	 * Apply content from output streams to document. It expects the partitioning
+	 * has or will update partitioning to reflect the change since it prevents this
+	 * partitioner's {@link #documentChanged2(DocumentEvent)} method from changing
+	 * partitioning.
+	 *
+	 * @param content       collected content from output streams
+	 * @param offset        offset where content is inserted
+	 * @param replaceLength length of overwritten old output
+	 */
+	private void applyOutputToDocument(String content, int offset, int replaceLength) {
+		if (content.length() > 0 || replaceLength > 0) {
+			if (ASSERT) {
+				Assert.isTrue(replaceLength <= content.length());
 			}
 			try {
 				updateType = DocUpdateType.OUTPUT;
-				document.replace(document.getLength(), 0, addedContent.toString());
+				document.replace(offset, replaceLength, content);
 			} catch (BadLocationException e) {
 				log(e);
 			}
 		}
-		checkBufferSize();
-		checkFinished();
 	}
 
 	/**
@@ -828,6 +1165,10 @@
 								p.setOffset(offset);
 								offset += p.getLength();
 							}
+
+							// fix output offset
+							int removedLength = cutOffset;
+							outputOffset = Math.max(outputOffset - removedLength, 0);
 						}
 						if (ASSERT) {
 							checkPartitions();
@@ -949,6 +1290,70 @@
 	}
 
 	/**
+	 * Check if console currently interprets ASCII control characters.
+	 *
+	 * @return <code>true</code> if console interprets ASCII control characters
+	 * @since 3.9
+	 */
+	public boolean isHandleControlCharacters() {
+		return controlCharacterPattern != null;
+	}
+
+	/**
+	 * Enable or disable interpretation of ASCII control characters like backspace
+	 * (<code>\b</code>).
+	 *
+	 * @param handleControlCharacters interpret control characters if
+	 *                                <code>true</code>
+	 * @since 3.9
+	 */
+	public void setHandleControlCharacters(boolean handleControlCharacters) {
+		if (handleControlCharacters) {
+			controlCharacterPattern = Pattern
+					.compile(carriageReturnAsControlCharacter ? CONTROL_CHARACTERS_WITH_CR_PATTERN_STR
+							: CONTROL_CHARACTERS_PATTERN_STR);
+		} else {
+			controlCharacterPattern = null;
+		}
+	}
+
+	/**
+	 * Check if carriage returns (<code>\r</code>) are interpreted as control
+	 * characters. They are also not interpreted if general control character
+	 * handling is disabled.
+	 *
+	 * @return if <code>true</code> carriage returns are interpreted as control
+	 *         characters.
+	 * @see #isHandleControlCharacters()
+	 * @since 3.9
+	 */
+	public boolean isCarriageReturnAsControlCharacter() {
+		return carriageReturnAsControlCharacter;
+	}
+
+	/**
+	 * If control characters are interpreted by this console carriage returns
+	 * (<code>\r</code>) are either ignored (<code>false</code>) and usually handled
+	 * as line break by connected console document or if <code>true</code>
+	 * interpreted with there control character meaning.
+	 * <p>
+	 * Note: this option has no effect if control character interpretation is
+	 * disabled in general.
+	 * </p>
+	 *
+	 * @param carriageReturnAsControlCharacter set <code>false</code> to exclude
+	 *                                         carriage return from control
+	 *                                         character interpretation
+	 * @see #setHandleControlCharacters(boolean)
+	 * @since 3.9
+	 */
+	public void setCarriageReturnAsControlCharacter(boolean carriageReturnAsControlCharacter) {
+		this.carriageReturnAsControlCharacter = carriageReturnAsControlCharacter;
+		// reset to update control character pattern
+		setHandleControlCharacters(isHandleControlCharacters());
+	}
+
+	/**
 	 * Get a partition by its index. Safe from out of bounds exceptions.
 	 *
 	 * @param index index of requested partition