org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/VerboseWriter.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2012 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdi.internal;

 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;

 public class VerboseWriter {
 	/** Length of verbose description. */
 	public static final int VERBOSE_DESCRIPTION_LENGTH = 21;
 	/** Number of hexadecimal verbose bytes per line. */
 	public static final int VERBOSE_HEX_BYTES_PER_LINE = 16;
 	/** Width of hex dump. */
 	public static final int VERBOSE_HEX_WIDTH = 16 * 3 + 2;

 	/**
 	 * Number extra verbose lines. These are caused by hex dumps that span more
 	 * than one line.
 	 */
 	int fExtraVerboseLines = 0;

 	/** PrintWriter that is written to. */
 	private PrintWriter fOutput;
 	/** Buffer for output: one StringBuffer entry per line. */
 	private List<StringBuffer> fLineBuffer;
 	/** Position from where buffer is written to. */
 	private int fPosition;
 	/** True if the current line has not yet been written to. */
 	private boolean fNewLine = true;

 	/**
 	 * Creates new VerboseWriter that writes to the given PrintWriter. Output is
 	 * buffered and previous entries in the buffer can be rewritten.
 	 */
 	public VerboseWriter(PrintWriter out) {
 		fOutput = out;
 		fLineBuffer = new ArrayList<StringBuffer>();
 		fPosition = 0;
 		fLineBuffer.add(new StringBuffer());
 	}

 	/**
 	 * Terminate the current line by writing the line separator string. If
 	 * autoflush is set and there are extra vebose lines caused by printHex,
 	 * these lines are also printed.
 	 */
 	public void println() {
 		while (fExtraVerboseLines > 0) {
 			fExtraVerboseLines--;
 			markLn();
 		}

 		markLn();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, byte value) {
 		printDescription(description);
 		printHex(value);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, short value) {
 		printDescription(description);
 		printHex(value);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, int value) {
 		printDescription(description);
 		printHex(value);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, long value) {
 		printDescription(description);
 		printHex(value);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, byte value, Map<Integer, String> valueToString) {
 		printDescription(description);
 		printHex(value);
 		printValue(value, valueToString);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, short value, Map<Integer, String> valueToString) {
 		printDescription(description);
 		printHex(value);
 		printValue(value, valueToString);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, int value, Map<Integer, String> valueToString) {
 		printDescription(description);
 		printHex(value);
 		printValue(value, valueToString);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, byte value, String[] bitNames) {
 		printDescription(description);
 		printHex(value);
 		printValue(value, bitNames);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, short value, String[] bitNames) {
 		printDescription(description);
 		printHex(value);
 		printValue(value, bitNames);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, int value, String[] bitNames) {
 		printDescription(description);
 		printHex(value);
 		printValue(value, bitNames);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, String value) {
 		printDescription(description);
 		printHex(value);
 		print(value);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, boolean value) {
 		printDescription(description);
 		printHex(value);
 		print(Boolean.valueOf(value).toString());
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, char value) {
 		printDescription(description);
 		printHex(value);
 		print(value);
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, double value) {
 		printDescription(description);
 		printHex(value);
 		print(new Double(value).toString());
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, float value) {
 		printDescription(description);
 		printHex(value);
 		print(new Float(value).toString());
 		println();
 	}

 	/**
 	 * Prints verbose line.
 	 */
 	public void println(String description, byte[] value) {
 		printDescription(description);
 		printHex(value);
 		println();
 	}

 	/**
 	 * Prints string with right size.
 	 */
 	public void printWidth(String str, int width) {
 		print(str);
 		int spaces = width - str.length();
 		if (spaces > 0) {
 			for (int i = 0; i < spaces; i++) {
 				print(' ');
 			}
 		}
 	}

 	/**
 	 * Prints description string with right size plus its seperator spaces.
 	 */
 	public void printDescription(String str) {
 		printWidth(str, VERBOSE_DESCRIPTION_LENGTH);
 	}

 	/**
 	 * Prints hex substitution string with right size plus its seperator spaces.
 	 */
 	public void printHexSubstitution(String str) {
 		// Note that bytes also start with a space.
 		print(' ');
 		printWidth(str, VERBOSE_HEX_WIDTH - 1);
 	}

 	/**
 	 * Appends hex representation of given byte to an array.
 	 */
 	private static void appendHexByte(byte b, char[] buffer, int pos) {
 		int count = 2;

 		int abspos = 3 * pos;
 		buffer[abspos] = ' ';
 		do {
 			int t = b & 15;
 			if (t > 9) {
 				t = t - 10 + 'a';
 			} else {
 				t += '0';
 			}
 			buffer[count-- + abspos] = (char) t;
 			b >>>= 4;
 		} while (count > 0);
 	}

 	/**
 	 * Appends remaining spaces to hex dump.
 	 */
 	private static void appendHexSpaces(char[] buffer, int pos) {
 		for (int i = 3 * pos; i <= VERBOSE_HEX_WIDTH - 3; i += 3) {
 			buffer[i] = ' ';
 			buffer[i + 1] = ' ';
 			buffer[i + 2] = ' ';
 		}

 		// Two extra spaces as seperator
 		buffer[VERBOSE_HEX_WIDTH - 1] = ' ';
 		buffer[VERBOSE_HEX_WIDTH - 2] = ' ';
 	}

 	/**
 	 * Prints hex representation of a byte.
 	 */
 	public void printHex(byte b) {
 		char buffer[] = new char[VERBOSE_HEX_WIDTH];
 		appendHexByte(b, buffer, 0);
 		appendHexSpaces(buffer, 1);
 		print(buffer);
 	}

 	/**
 	 * Prints hex representation of an int.
 	 */
 	public void printHex(short s) {
 		char buffer[] = new char[VERBOSE_HEX_WIDTH];
 		for (int i = 1; i >= 0; i--)
 			appendHexByte((byte) (s >>> i * 8), buffer, 1 - i);
 		appendHexSpaces(buffer, 2);
 		print(buffer);
 	}

 	/**
 	 * Prints hex representation of an int.
 	 */
 	public void printHex(int integer) {
 		char buffer[] = new char[VERBOSE_HEX_WIDTH];
 		for (int i = 3; i >= 0; i--)
 			appendHexByte((byte) (integer >>> i * 8), buffer, 3 - i);
 		appendHexSpaces(buffer, 4);
 		print(buffer);
 	}

 	/**
 	 * Prints hex representation of a long.
 	 */
 	public void printHex(long l) {
 		char buffer[] = new char[VERBOSE_HEX_WIDTH];
 		for (int i = 7; i >= 0; i--)
 			appendHexByte((byte) (l >>> i * 8), buffer, 7 - i);
 		appendHexSpaces(buffer, 8);
 		print(buffer);
 	}

 	/**
 	 * Prints hex representation of a long.
 	 * @param b the boolean
 	 */
 	public void printHex(boolean b) {
 		printHexSubstitution("<boolean>"); //$NON-NLS-1$
 	}

 	/**
 	 * Prints hex representation of a long.
 	 * @param c the char
 	 */
 	public void printHex(char c) {
 		printHexSubstitution("<char>"); //$NON-NLS-1$
 	}

 	/**
 	 * Prints hex representation of a long.
 	 * @param d the double
 	 */
 	public void printHex(double d) {
 		printHexSubstitution("<double>"); //$NON-NLS-1$
 	}

 	/**
 	 * Prints hex representation of a long.
 	 * @param f the float
 	 */
 	public void printHex(float f) {
 		printHexSubstitution("<float>"); //$NON-NLS-1$
 	}

 	/**
 	 * Prints hex representation of a String.
 	 * @param str the string
 	 */
 	public void printHex(String str) {
 		printHexSubstitution("<string>"); //$NON-NLS-1$
 	}

 	/**
 	 * Prints hex representation of a byte array. Note that this can span more
 	 * than one line, but is considered to be part of one 'verbose line'.
 	 * Therefore, a println after a printHex can result in more than one line
 	 * being printed to the PrintWriter.
 	 */
 	public void printHex(byte[] bytes) {
 		int startPosition = position();
 		char linebuf[] = new char[VERBOSE_HEX_WIDTH];
 		int extraLines = 0;
 		int byteOnLine = 0;

 		for (byte b : bytes) {
 			if (byteOnLine == VERBOSE_HEX_BYTES_PER_LINE) {
 				appendHexSpaces(linebuf, VERBOSE_HEX_BYTES_PER_LINE);
 				if (extraLines++ > 0) {
 					printDescription(""); //$NON-NLS-1$
 				}
 				print(linebuf);
 				markLn();
 				byteOnLine = 0;
 			}
 			appendHexByte(b, linebuf, byteOnLine++);
 		}
 		appendHexSpaces(linebuf, byteOnLine);
 		if (extraLines > 0) {
 			printDescription(""); //$NON-NLS-1$
 		}

 		fExtraVerboseLines += extraLines;
 		print(linebuf);
 		if (extraLines > 0) {
 			gotoPosition(startPosition);
 		}
 	}

 	/**
 	 * Prints string representation of a value given a Map from values to
 	 * strings.
 	 */
 	public void printValue(int value, Map<Integer, String> valueToString) {
 		Integer val = new Integer(value);
 		if (valueToString == null) {
 			print(val.toString());
 			return;
 		}
 		String result = valueToString.get(val);
 		if (result == null) {
 			print(val.toString() + JDIMessages.VerboseWriter___unknown_value__1);
 		} else {
 			print(result);
 		}
 	}

 	/**
 	 * Prints string representation of a value given a Vector with the names of
 	 * the bits.
 	 */
 	public void printValue(byte value, String[] bitNames) {
 		printValue(value & 0xff, bitNames);
 	}

 	/**
 	 * Prints string representation of a value given a Vector with the names of
 	 * the bits.
 	 */
 	public void printValue(short value, String[] bitNames) {
 		printValue(value & 0xffff, bitNames);
 	}

 	/**
 	 * Prints string representation of a value given a Vector with the names of
 	 * the bits.
 	 */
 	public void printValue(int value, String[] bitNames) {
 		Integer val = new Integer(value);
 		if (bitNames == null) {
 			print(val.toString());
 			return;
 		}

 		boolean bitsSet = false;

 		for (int i = 0; i < bitNames.length; i++) {
 			// Test if bit is set in value.
 			if ((1 << i & value) == 0) {
 				continue;
 			}

 			// See if we have a desciption for the bit.
 			String bitString = bitNames[i];
 			if (bitString == null) {
 				bitString = JDIMessages.VerboseWriter__unknown_bit__2;
 			}

 			if (!bitsSet) {
 				print(bitString);
 			} else {
 				print(" & "); //$NON-NLS-1$
 				print(bitString);
 			}
 			bitsSet = true;
 		}

 		if (!bitsSet) {
 			print(JDIMessages.VerboseWriter__none__4);
 		}
 	}

 	/**
 	 * Checks if a new line is written to. If so, first erase any data on that
 	 * line. Line is marked 'not new' after this command.
 	 */
 	private void checkForNewLine() {
 		if (fNewLine) {
 			(fLineBuffer.get(fPosition)).setLength(0);
 			fNewLine = false;
 		}
 	}

 	/**
 	 * Print a String.
 	 */
 	public void print(String str) {
 		checkForNewLine();
 		(fLineBuffer.get(fPosition)).append(str);
 	}

 	/**
 	 * Print a Character.
 	 */
 	public void print(char c) {
 		checkForNewLine();
 		(fLineBuffer.get(fPosition)).append(c);
 	}

 	/**
 	 * Print array of Characters.
 	 */
 	public void print(char[] c) {
 		checkForNewLine();
 		(fLineBuffer.get(fPosition)).append(c);
 	}

 	/**
 	 * Print a String and then terminate the line.
 	 */
 	public void println(String str) {
 		print(str);
 		println();
 	}

 	/**
 	 * Flush buffer. If autoflush is off, this method is synchronized on the
 	 * PrintWriter given in the constructor.
 	 */
 	public void flush() {
 		synchronized (fOutput) {
 			int bufSize = fLineBuffer.size();

 			for (int i = 0; i < bufSize - 1; i++)
 				fOutput.println(new String(fLineBuffer.get(i)));

 			// The last line should be printed without an extra newline
 			StringBuffer lastLine = fLineBuffer.get(bufSize - 1);
 			if (lastLine.length() > 0)
 				fOutput.print(new String(lastLine));

 			fOutput.flush();
 			fLineBuffer.clear();
 			fPosition = 0;
 			fLineBuffer.add(new StringBuffer());
 		}
 	}

 	/**
 	 * Go to the given position in the buffer. If the given position is smaller
 	 * than the current position, subsequent print commands overwrite existing
 	 * lines in the buffer. Else, new lines are added to the buffer.
 	 */
 	public void gotoPosition(int pos) {
 		int delta = pos - fPosition;
 		if (delta < 0) {
 			fPosition = pos;
 		} else {
 			while (delta-- > 0)
 				println();
 		}
 	}

 	/**
 	 * Prints given number of lines.
 	 */
 	public void printLines(int lines) {
 		gotoPosition(fPosition + lines);
 	}

 	/**
 	 * @return Returns current position in buffer.
 	 */
 	public int position() {
 		return fPosition;
 	}

 	/**
 	 * Terminate the current line by writing the line separator string, start at
 	 * end of next line.
 	 */
 	public void markLn() {
 		if (++fPosition == fLineBuffer.size()) {
 			fLineBuffer.add(new StringBuffer());
 		}

 		fNewLine = true;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2012 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdi.internal;

	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;

	public class VerboseWriter {
	/** Length of verbose description. */
	public static final int VERBOSE_DESCRIPTION_LENGTH = 21;
	/** Number of hexadecimal verbose bytes per line. */
	public static final int VERBOSE_HEX_BYTES_PER_LINE = 16;
	/** Width of hex dump. */
	public static final int VERBOSE_HEX_WIDTH = 16 * 3 + 2;

	/**
	* Number extra verbose lines. These are caused by hex dumps that span more
	* than one line.
	*/
	int fExtraVerboseLines = 0;

	/** PrintWriter that is written to. */
	private PrintWriter fOutput;
	/** Buffer for output: one StringBuffer entry per line. */
	private List<StringBuffer> fLineBuffer;
	/** Position from where buffer is written to. */
	private int fPosition;
	/** True if the current line has not yet been written to. */
	private boolean fNewLine = true;

	/**
	* Creates new VerboseWriter that writes to the given PrintWriter. Output is
	* buffered and previous entries in the buffer can be rewritten.
	*/
	public VerboseWriter(PrintWriter out) {
	fOutput = out;
	fLineBuffer = new ArrayList<StringBuffer>();
	fPosition = 0;
	fLineBuffer.add(new StringBuffer());
	}

	/**
	* Terminate the current line by writing the line separator string. If
	* autoflush is set and there are extra vebose lines caused by printHex,
	* these lines are also printed.
	*/
	public void println() {
	while (fExtraVerboseLines > 0) {
	fExtraVerboseLines--;
	markLn();
	}

	markLn();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, byte value) {
	printDescription(description);
	printHex(value);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, short value) {
	printDescription(description);
	printHex(value);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, int value) {
	printDescription(description);
	printHex(value);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, long value) {
	printDescription(description);
	printHex(value);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, byte value, Map<Integer, String> valueToString) {
	printDescription(description);
	printHex(value);
	printValue(value, valueToString);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, short value, Map<Integer, String> valueToString) {
	printDescription(description);
	printHex(value);
	printValue(value, valueToString);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, int value, Map<Integer, String> valueToString) {
	printDescription(description);
	printHex(value);
	printValue(value, valueToString);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, byte value, String[] bitNames) {
	printDescription(description);
	printHex(value);
	printValue(value, bitNames);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, short value, String[] bitNames) {
	printDescription(description);
	printHex(value);
	printValue(value, bitNames);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, int value, String[] bitNames) {
	printDescription(description);
	printHex(value);
	printValue(value, bitNames);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, String value) {
	printDescription(description);
	printHex(value);
	print(value);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, boolean value) {
	printDescription(description);
	printHex(value);
	print(Boolean.valueOf(value).toString());
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, char value) {
	printDescription(description);
	printHex(value);
	print(value);
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, double value) {
	printDescription(description);
	printHex(value);
	print(new Double(value).toString());
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, float value) {
	printDescription(description);
	printHex(value);
	print(new Float(value).toString());
	println();
	}

	/**
	* Prints verbose line.
	*/
	public void println(String description, byte[] value) {
	printDescription(description);
	printHex(value);
	println();
	}

	/**
	* Prints string with right size.
	*/
	public void printWidth(String str, int width) {
	print(str);
	int spaces = width - str.length();
	if (spaces > 0) {
	for (int i = 0; i < spaces; i++) {
	print(' ');
	}
	}
	}

	/**
	* Prints description string with right size plus its seperator spaces.
	*/
	public void printDescription(String str) {
	printWidth(str, VERBOSE_DESCRIPTION_LENGTH);
	}

	/**
	* Prints hex substitution string with right size plus its seperator spaces.
	*/
	public void printHexSubstitution(String str) {
	// Note that bytes also start with a space.
	print(' ');
	printWidth(str, VERBOSE_HEX_WIDTH - 1);
	}

	/**
	* Appends hex representation of given byte to an array.
	*/
	private static void appendHexByte(byte b, char[] buffer, int pos) {
	int count = 2;

	int abspos = 3 * pos;
	buffer[abspos] = ' ';
	do {
	int t = b & 15;
	if (t > 9) {
	t = t - 10 + 'a';
	} else {
	t += '0';
	}
	buffer[count-- + abspos] = (char) t;
	b >>>= 4;
	} while (count > 0);
	}

	/**
	* Appends remaining spaces to hex dump.
	*/
	private static void appendHexSpaces(char[] buffer, int pos) {
	for (int i = 3 * pos; i <= VERBOSE_HEX_WIDTH - 3; i += 3) {
	buffer[i] = ' ';
	buffer[i + 1] = ' ';
	buffer[i + 2] = ' ';
	}

	// Two extra spaces as seperator
	buffer[VERBOSE_HEX_WIDTH - 1] = ' ';
	buffer[VERBOSE_HEX_WIDTH - 2] = ' ';
	}

	/**
	* Prints hex representation of a byte.
	*/
	public void printHex(byte b) {
	char buffer[] = new char[VERBOSE_HEX_WIDTH];
	appendHexByte(b, buffer, 0);
	appendHexSpaces(buffer, 1);
	print(buffer);
	}

	/**
	* Prints hex representation of an int.
	*/
	public void printHex(short s) {
	char buffer[] = new char[VERBOSE_HEX_WIDTH];
	for (int i = 1; i >= 0; i--)
	appendHexByte((byte) (s >>> i * 8), buffer, 1 - i);
	appendHexSpaces(buffer, 2);
	print(buffer);
	}

	/**
	* Prints hex representation of an int.
	*/
	public void printHex(int integer) {
	char buffer[] = new char[VERBOSE_HEX_WIDTH];
	for (int i = 3; i >= 0; i--)
	appendHexByte((byte) (integer >>> i * 8), buffer, 3 - i);
	appendHexSpaces(buffer, 4);
	print(buffer);
	}

	/**
	* Prints hex representation of a long.
	*/
	public void printHex(long l) {
	char buffer[] = new char[VERBOSE_HEX_WIDTH];
	for (int i = 7; i >= 0; i--)
	appendHexByte((byte) (l >>> i * 8), buffer, 7 - i);
	appendHexSpaces(buffer, 8);
	print(buffer);
	}

	/**
	* Prints hex representation of a long.
	* @param b the boolean
	*/
	public void printHex(boolean b) {
	printHexSubstitution("<boolean>"); //$NON-NLS-1$
	}

	/**
	* Prints hex representation of a long.
	* @param c the char
	*/
	public void printHex(char c) {
	printHexSubstitution("<char>"); //$NON-NLS-1$
	}

	/**
	* Prints hex representation of a long.
	* @param d the double
	*/
	public void printHex(double d) {
	printHexSubstitution("<double>"); //$NON-NLS-1$
	}

	/**
	* Prints hex representation of a long.
	* @param f the float
	*/
	public void printHex(float f) {
	printHexSubstitution("<float>"); //$NON-NLS-1$
	}

	/**
	* Prints hex representation of a String.
	* @param str the string
	*/
	public void printHex(String str) {
	printHexSubstitution("<string>"); //$NON-NLS-1$
	}

	/**
	* Prints hex representation of a byte array. Note that this can span more
	* than one line, but is considered to be part of one 'verbose line'.
	* Therefore, a println after a printHex can result in more than one line
	* being printed to the PrintWriter.
	*/
	public void printHex(byte[] bytes) {
	int startPosition = position();
	char linebuf[] = new char[VERBOSE_HEX_WIDTH];
	int extraLines = 0;
	int byteOnLine = 0;

	for (byte b : bytes) {
	if (byteOnLine == VERBOSE_HEX_BYTES_PER_LINE) {
	appendHexSpaces(linebuf, VERBOSE_HEX_BYTES_PER_LINE);
	if (extraLines++ > 0) {
	printDescription(""); //$NON-NLS-1$
	}
	print(linebuf);
	markLn();
	byteOnLine = 0;
	}
	appendHexByte(b, linebuf, byteOnLine++);
	}
	appendHexSpaces(linebuf, byteOnLine);
	if (extraLines > 0) {
	printDescription(""); //$NON-NLS-1$
	}

	fExtraVerboseLines += extraLines;
	print(linebuf);
	if (extraLines > 0) {
	gotoPosition(startPosition);
	}
	}

	/**
	* Prints string representation of a value given a Map from values to
	* strings.
	*/
	public void printValue(int value, Map<Integer, String> valueToString) {
	Integer val = new Integer(value);
	if (valueToString == null) {
	print(val.toString());
	return;
	}
	String result = valueToString.get(val);
	if (result == null) {
	print(val.toString() + JDIMessages.VerboseWriter___unknown_value__1);
	} else {
	print(result);
	}
	}

	/**
	* Prints string representation of a value given a Vector with the names of
	* the bits.
	*/
	public void printValue(byte value, String[] bitNames) {
	printValue(value & 0xff, bitNames);
	}

	/**
	* Prints string representation of a value given a Vector with the names of
	* the bits.
	*/
	public void printValue(short value, String[] bitNames) {
	printValue(value & 0xffff, bitNames);
	}

	/**
	* Prints string representation of a value given a Vector with the names of
	* the bits.
	*/
	public void printValue(int value, String[] bitNames) {
	Integer val = new Integer(value);
	if (bitNames == null) {
	print(val.toString());
	return;
	}

	boolean bitsSet = false;

	for (int i = 0; i < bitNames.length; i++) {
	// Test if bit is set in value.
	if ((1 << i & value) == 0) {
	continue;
	}

	// See if we have a desciption for the bit.
	String bitString = bitNames[i];
	if (bitString == null) {
	bitString = JDIMessages.VerboseWriter__unknown_bit__2;
	}

	if (!bitsSet) {
	print(bitString);
	} else {
	print(" & "); //$NON-NLS-1$
	print(bitString);
	}
	bitsSet = true;
	}

	if (!bitsSet) {
	print(JDIMessages.VerboseWriter__none__4);
	}
	}

	/**
	* Checks if a new line is written to. If so, first erase any data on that
	* line. Line is marked 'not new' after this command.
	*/
	private void checkForNewLine() {
	if (fNewLine) {
	(fLineBuffer.get(fPosition)).setLength(0);
	fNewLine = false;
	}
	}

	/**
	* Print a String.
	*/
	public void print(String str) {
	checkForNewLine();
	(fLineBuffer.get(fPosition)).append(str);
	}

	/**
	* Print a Character.
	*/
	public void print(char c) {
	checkForNewLine();
	(fLineBuffer.get(fPosition)).append(c);
	}

	/**
	* Print array of Characters.
	*/
	public void print(char[] c) {
	checkForNewLine();
	(fLineBuffer.get(fPosition)).append(c);
	}

	/**
	* Print a String and then terminate the line.
	*/
	public void println(String str) {
	print(str);
	println();
	}

	/**
	* Flush buffer. If autoflush is off, this method is synchronized on the
	* PrintWriter given in the constructor.
	*/
	public void flush() {
	synchronized (fOutput) {
	int bufSize = fLineBuffer.size();

	for (int i = 0; i < bufSize - 1; i++)
	fOutput.println(new String(fLineBuffer.get(i)));

	// The last line should be printed without an extra newline
	StringBuffer lastLine = fLineBuffer.get(bufSize - 1);
	if (lastLine.length() > 0)
	fOutput.print(new String(lastLine));

	fOutput.flush();
	fLineBuffer.clear();
	fPosition = 0;
	fLineBuffer.add(new StringBuffer());
	}
	}

	/**
	* Go to the given position in the buffer. If the given position is smaller
	* than the current position, subsequent print commands overwrite existing
	* lines in the buffer. Else, new lines are added to the buffer.
	*/
	public void gotoPosition(int pos) {
	int delta = pos - fPosition;
	if (delta < 0) {
	fPosition = pos;
	} else {
	while (delta-- > 0)
	println();
	}
	}

	/**
	* Prints given number of lines.
	*/
	public void printLines(int lines) {
	gotoPosition(fPosition + lines);
	}

	/**
	* @return Returns current position in buffer.
	*/
	public int position() {
	return fPosition;
	}

	/**
	* Terminate the current line by writing the line separator string, start at
	* end of next line.
	*/
	public void markLn() {
	if (++fPosition == fLineBuffer.size()) {
	fLineBuffer.add(new StringBuffer());
	}

	fNewLine = true;
	}
	}