BndScanner: error odd num backslashes

For #6894
Single backslashes are silently dropped by Java Properties parsing (https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Properties.html). This causes confusing behavior since bnd allows that they can be entered in the source editor. This is an attempt to show red markers for such illegal single backslashes. the only valid single backslash is still the line-continuation (for multiline support)

refactor for testcase

- debug logging commented for performance. just uncomment during development, since it is very helpful output

Signed-off-by: Christoph Rueger <[email protected]>

Author: chrisrueger

bndtools.core/src/bndtools/editor/completion/BackslashValidator.java

@@ -0,0 +1,156 @@
+package bndtools.editor.completion;
+
+import org.eclipse.jface.text.rules.ICharacterScanner;
+
+import aQute.lib.hex.Hex;
+
+public final class BackslashValidator {
+
+    public enum Result {
+        UNDEFINED,    // valid escape or even run
+        ERROR,        // invalid backslash sequence (e.g., \ followed by space)
+        REFRESH       // odd backslash at EOF, to refresh partition
+    }
+
+	/**
+	 * Handles a sequence of backslashes and determines whether it forms a valid
+	 * escape, line continuation, or an error sequence.
+	 * <p>
+	 * Rules:
+	 * <ul>
+	 * <li>Even-length runs of backslashes are always valid (all characters are
+	 * unread).</li>
+	 * <li>Odd-length runs are followed by:
+	 * <ul>
+	 * <li>Line breaks (\n or \r) → valid line continuation, unread buffer,
+	 * return UNDEFINED</li>
+	 * <li>EOF → return T_DEFAULT to refresh partition in Eclipse (prevents
+	 * sticky red)</li>
+	 * <li>Space or tab → invalid sequence, consume spaces, return T_ERROR</li>
+	 * <li>Valid escape characters (\t, \n, \r, \f, \\, :, =, #, !, or Unicode
+	 * \\uXXXX) → unread buffer, return UNDEFINED</li>
+	 * <li>Anything else → invalid, return T_ERROR</li>
+	 * </ul>
+	 * </li>
+	 * </ul>
+	 * <p>
+	 * The method always maintains scanner consistency by using a buffer to
+	 * unread non-error characters, ensuring the scanner position is restored.
+	 *
+	 * @param scanner the character scanner
+	 * @param first the first character read (must be a backslash to enter
+	 *            processing)
+	 * @return a token indicating UNDEFINED, T_ERROR, or T_DEFAULT for EOF
+	 */
+	public static Result handleBackslashes(ICharacterScanner scanner, int first) {
+		StringBuilder buffer = new StringBuilder();
+		buffer.append((char) first);
+
+		// dbg("handleBackspaces(): first='%c' (%d)", first, first);
+
+		if (first != '\\') {
+			unreadBuffer(scanner, buffer);
+			// dbg("not a backslash → UNDEFINED");
+			return Result.UNDEFINED;
+		}
+
+		int c;
+		// count consecutive backslashes
+		int runLen = 1;
+		while (true) {
+			int peek = scanner.read();
+			if (peek == ICharacterScanner.EOF || peek != '\\') {
+				c = peek; // next char after run
+				break;
+			}
+			buffer.append((char) peek);
+			runLen++;
+		}
+		boolean odd = (runLen & 1) == 1;
+
+		if (!odd) {
+			unreadBuffer(scanner, buffer); // even run → unread everything
+			// dbg("even runLen=%d → UNDEFINED", runLen);
+			return Result.UNDEFINED;
+		}
+
+		// odd backslash → check next char
+		if (c == '\n' || c == '\r') {
+			unreadBuffer(scanner, buffer);
+			// dbg("odd backslash but line continuation → UNDEFINED");
+			return Result.UNDEFINED;
+		}
+
+		if (c == ICharacterScanner.EOF) {
+			unreadBuffer(scanner, buffer);
+			// dbg("odd backslash at EOF → return T_DEFAULT to refresh
+			// partition");
+			return Result.REFRESH; // forces partition update
+		}
+
+		if (c == ' ' || c == '\t') {
+			// consume all spaces
+			do {
+				c = scanner.read();
+				if (c == ICharacterScanner.EOF)
+					break;
+				buffer.append((char) c);
+			} while (c == ' ' || c == '\t');
+
+			if (c != ICharacterScanner.EOF)
+				scanner.unread(); // unread first non-space
+
+			// dbg("invalid '\\ ' sequence → ERROR");
+			return Result.ERROR; // leave buffer consumed for error only
+		}
+
+		// Valid single-character escapes
+		if ("tnrf\\=:#!".indexOf(c) >= 0) {
+			unreadBuffer(scanner, buffer); // valid escape → unread everything
+			// dbg("valid escape '\\%c' → UNDEFINED", c);
+			return Result.UNDEFINED;
+
+		}
+
+		// Unicode escape
+		if (c == 'u') {
+			// unicode check borrowed from
+			// aQute.lib.utf8properties.PropertiesParser.backslash()
+			// read 4 hex digits after \\u
+			StringBuilder sb = new StringBuilder();
+			for (int i = 0; i < 4; i++) {
+				int ch = scanner.read();
+				if (ch == ICharacterScanner.EOF)
+					break;
+				sb.append((char) ch);
+			}
+			String unicode = sb.toString();
+			if (unicode.length() != 4 || !Hex.isHex(unicode)) {
+				// dbg("invalid unicode escape: \\u%s → ERROR", unicode);
+				unreadBuffer(scanner, buffer);
+				return Result.ERROR;
+			} else {
+				// dbg("valid unicode escape: \\u%s → UNDEFINED", unicode);
+				unreadBuffer(scanner, buffer);
+				return Result.UNDEFINED;
+			}
+		}
+
+		// dbg("anything else after odd '\\' → ERROR");
+		return Result.ERROR;
+    }
+
+	private static void unreadBuffer(ICharacterScanner scanner, StringBuilder buffer) {
+		for (int i = buffer.length() - 1; i >= 0; i--)
+			scanner.unread();
+		// dbg("unreadBuffer() → put back %d chars", buffer.length());
+	}
+
+	/**
+	 * for debug logging. Currently all callers comment for performance reasons.
+	 */
+	static void dbg(String fmt, Object... args) {
+		System.out.printf("[BndScanner] " + fmt + "%n", args);
+	}
+
+}

bndtools.core/src/bndtools/editor/completion/BndScanner.java

@@ -116,23 +116,77 @@ IToken keyword(ICharacterScanner scanner) {
 		return bsvc.T_KEY;
 	}
 
+
+	/**
+	 * Scans for invalid backslash sequences in a Java properties file and
+	 * returns a token indicating the type of content.
+	 * <p>
+	 * This method detects:
+	 * <ul>
+	 * <li>Single backslashes at the end of the line or before EOF (line
+	 * continuation)</li>
+	 * <li>Invalid sequences such as a backslash followed by a space or tab
+	 * (error)</li>
+	 * <li>Valid escape sequences like \t, \n, \r, \f, \\, \:, \=, \#, \!, and
+	 * Unicode \\uXXXX</li>
+	 * </ul>
+	 * <p>
+	 * Implementation notes:
+	 * <ul>
+	 * <li>The first character is read and checked for a backslash.</li>
+	 * <li>All consecutive backslashes are collected into a buffer.</li>
+	 * <li>If the number of consecutive backslashes is even, it is valid and
+	 * unread back into the scanner.</li>
+	 * <li>If odd, the next character determines whether it is a valid escape,
+	 * line continuation, or error.</li>
+	 * <li>Special handling for EOF: a single backslash at EOF returns T_DEFAULT
+	 * instead of UNDEFINED to force Eclipse to refresh the partition and
+	 * prevent "sticky red" highlighting.</li>
+	 * <li>Buffering ensures scanner state is fully restored for non-error
+	 * sequences.</li>
+	 * </ul>
+	 *
+	 * @param scanner the character scanner
+	 * @return a token representing either UNDEFINED, T_ERROR, or T_DEFAULT for
+	 *         a valid backslash at EOF
+	 */
 	IToken error(ICharacterScanner scanner) {
-		int c = scanner.read();
-		int n = 1;
-		if (c == '\\') {
-			c = scanner.read();
-			n++;
-			if (c == ' ' || c == '\t') {
-				while (c == ' ' || c == '\t') {
-					c = scanner.read();
-				}
-				scanner.unread();
+		int startColumn = scanner.getColumn();
+		int first = scanner.read();
+		// BackslashValidator.dbg("error() start col=%d first='%s' (code=%d)",
+		// startColumn,
+		// (first == ICharacterScanner.EOF ? "<EOF>" : Character.toString((char)
+		// first)), first);
+
+		if (first == ICharacterScanner.EOF) {
+			return Token.UNDEFINED;
+		}
+
+		IToken token = handleBackspaces(scanner, first);
+		// BackslashValidator.dbg("→ return token=%s at col=%d%n",
+		// token.isUndefined() ? "UNDEFINED" : token.getData(),
+		// scanner.getColumn());
+		return token;
+	}
+
+
+	private IToken handleBackspaces(ICharacterScanner scanner, int first) {
+
+		// Use the shared helper to determine the result
+		BackslashValidator.Result result = BackslashValidator.handleBackslashes(scanner, first);
+
+		switch (result) {
+			case UNDEFINED :
+				return Token.UNDEFINED;
+			case ERROR :
 				return bsvc.T_ERROR;
-			}
+			case REFRESH :
+				return bsvc.T_DEFAULT; // forces partition refresh
+			default :
+				return Token.UNDEFINED;
 		}
-		while (n-- > 0)
-			scanner.unread();
-		return Token.UNDEFINED;
 	}
 
+
+
 }