/*******************************************************************************
* Copyright (c) 2006, 2015 Wind River Systems, Inc. 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:
* Ted R Williams (Wind River Systems, Inc.) - initial implementation
* Randy Rohrbach (Wind River Systems, Inc.) - Copied and modified to create the floating point plugin
*******************************************************************************/
package org.eclipse.cdt.debug.ui.memory.floatingpoint;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
import org.eclipse.cdt.debug.ui.memory.floatingpoint.FPutilities.FPDataType;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IDebugEventSetListener;
import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.core.model.IMemoryBlock;
import org.eclipse.debug.core.model.IMemoryBlockExtension;
import org.eclipse.debug.core.model.MemoryByte;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.views.memory.MemoryViewUtil;
import org.eclipse.debug.internal.ui.views.memory.renderings.GoToAddressComposite;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Layout;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.UIJob;
@SuppressWarnings("restriction")
public class Rendering extends Composite implements IDebugEventSetListener
{
// The IMemoryRendering parent
private FPRendering fParent;
// Controls
protected FPAddressPane fAddressPane;
protected FPDataPane fDataPane;
private GoToAddressComposite fAddressBar;
protected Control fAddressBarControl;
private Selection fSelection = new Selection();
// Internal management
BigInteger fViewportAddress = null; // Default visibility for performance
BigInteger fMemoryBlockStartAddress = null; // Starting address
BigInteger fMemoryBlockEndAddress = null; // Ending address
protected BigInteger fBaseAddress = null; // Base address
protected int fColumnCount = 0; // Auto calculate can be disabled by user, making this user settable
protected int fBytesPerRow = 0; // Number of bytes per row are displayed
int fScrollSelection = 0; // Scroll selection
private BigInteger fCaretAddress = null; // Caret/cursor position
private boolean fCellEditState = false; // Cell editing mode: 'true' = currently editing a cell; 'false' = not editing a cell
private BigInteger cellEditAddress = null; // The address of the cell currently being edited
private BigInteger memoryAddress = null; // The memory address associated with the cell that currently being edited
private StringBuffer fEditBuffer = null; // Character buffer used during editing
static boolean initialDisplayModeSet = false; // Initial display mode been set to the same endianness as the target
// Constants used to identify the panes
public final static int PANE_ADDRESS = 1;
public final static int PANE_DATA = 2;
// Decimal precision used when converting between scroll units and number of memory
// rows. Calculations do not need to be exact; two decimal places is good enough.
static private final MathContext SCROLL_CONVERSION_PRECISION = new MathContext(2);
// Constants used to identify text, maybe java should be queried for all available sets
public final static int TEXT_ISO_8859_1 = 1;
public final static int TEXT_USASCII = 2;
public final static int TEXT_UTF8 = 3;
protected final static int TEXT_UTF16 = 4;
// Internal constants
public final static int COLUMNS_AUTO_SIZE_TO_FIT = 0;
// View internal settings
private int fCellPadding = 2;
private int fPaneSpacing = 16;
private String fPaddingString = " "; //$NON-NLS-1$
// Flag whether the memory cache is dirty
private boolean fCacheDirty = false;
// Update modes
public final static int UPDATE_ALWAYS = 1;
public final static int UPDATE_ON_BREAKPOINT = 2;
public final static int UPDATE_MANUAL = 3;
public int fUpdateMode = UPDATE_ALWAYS;
// Constants for cell-width calculations
private static final int DECIMAL_POINT_SIZE = 1;
private static final int SIGN_SIZE = 1;
private static final int EXPONENT_CHARACTER_SIZE = 1;
private static final int EXPONENT_VALUE_SIZE = 3;
// User settings
private FPDataType fFPDataType = FPDataType.FLOAT; // Default to float data type
private int fDisplayedPrecision = 8; // The default number of digits of displayed precision
private int fCharsPerColumn = charsPerColumn(); // Figure out the initial cell-width size
private int fColumnsSetting = COLUMNS_AUTO_SIZE_TO_FIT; // Default column setting
private boolean fIsTargetLittleEndian = true; // Default target endian setting
private boolean fIsDisplayLittleEndian = true; // Default display endian setting
private boolean fEditInserMode = false; // Insert mode: true = replace existing number, false = overstrike
// Constructors
public Rendering(Composite parent, FPRendering renderingParent)
{
super(parent, SWT.DOUBLE_BUFFERED | SWT.NO_BACKGROUND | SWT.H_SCROLL | SWT.V_SCROLL);
this.setFont(JFaceResources.getFont(IInternalDebugUIConstants.FONT_NAME)); // TODO: internal?
this.fParent = renderingParent;
// Initialize the viewport start
if (fParent.getMemoryBlock() != null)
{
// This is base address from user.
// Honor it if the block has no limits or the base is within the block limits.
// Fix Bug 414519.
BigInteger base = fParent.getBigBaseAddress();
fViewportAddress = fParent.getMemoryBlockStartAddress();
// The viewport address will be null if memory may be retrieved at any
// address less than this memory block's base. If so use the base address.
if (fViewportAddress == null)
fViewportAddress = base;
else {
BigInteger blockEndAddr = fParent.getMemoryBlockEndAddress();
if (base.compareTo(fViewportAddress) > 0) {
if (blockEndAddr == null || base.compareTo(blockEndAddr) < 0)
fViewportAddress = base;
}
}
fBaseAddress = fViewportAddress;
}
// Instantiate the panes, TODO default visibility from state or plugin.xml?
this.fAddressPane = createAddressPane();
this.fDataPane = createDataPane();
fAddressBar = new GoToAddressComposite();
fAddressBarControl = fAddressBar.createControl(parent);
Button button = fAddressBar.getButton(IDialogConstants.OK_ID);
if (button != null)
{
button.addSelectionListener(new SelectionAdapter()
{
@Override
public void widgetSelected(SelectionEvent e)
{
doGoToAddress();
}
});
button = fAddressBar.getButton(IDialogConstants.CANCEL_ID);
if (button != null)
{
button.addSelectionListener(new SelectionAdapter()
{
@Override
public void widgetSelected(SelectionEvent e)
{
setVisibleAddressBar(false);
}
});
}
}
fAddressBar.getExpressionWidget().addSelectionListener(new SelectionAdapter()
{
@Override
public void widgetDefaultSelected(SelectionEvent e)
{
doGoToAddress();
}
});
fAddressBar.getExpressionWidget().addKeyListener(new KeyAdapter()
{
@Override
public void keyPressed(KeyEvent e)
{
if (e.keyCode == SWT.ESC)
setVisibleAddressBar(false);
super.keyPressed(e);
}
});
this.fAddressBarControl.setVisible(false);
getHorizontalBar().addSelectionListener(createHorizontalBarSelectionListener());
getVerticalBar().addSelectionListener(createVerticalBarSelectinListener());
this.addPaintListener(new PaintListener()
{
@Override
public void paintControl(PaintEvent pe)
{
pe.gc.setBackground(Rendering.this.getFPRendering().getColorBackground());
pe.gc.fillRectangle(0, 0, Rendering.this.getBounds().width, Rendering.this.getBounds().height);
}
});
setLayout();
this.addControlListener(new ControlListener()
{
@Override
public void controlMoved(ControlEvent ce)
{
}
@Override
public void controlResized(ControlEvent ce)
{
packColumns();
}
});
DebugPlugin.getDefault().addDebugEventListener(this);
}
// Determine how many characters are allowed in the column
private int charsPerColumn()
{
return fDisplayedPrecision + DECIMAL_POINT_SIZE + SIGN_SIZE + EXPONENT_CHARACTER_SIZE + EXPONENT_VALUE_SIZE + fCellPadding;
}
// Establish the visible layout of the view
protected void setLayout()
{
this.setLayout(new Layout()
{
@Override
public void layout(Composite composite, boolean changed)
{
int xOffset = 0;
if (Rendering.this.getHorizontalBar().isVisible())
xOffset = Rendering.this.getHorizontalBar().getSelection();
int x = xOffset * -1;
int y = 0;
if (fAddressBarControl.isVisible())
{
fAddressBarControl.setBounds(0, 0, Rendering.this.getBounds().width, fAddressBarControl.computeSize(100, 30).y); // FIXME
// y = fAddressBarControl.getBounds().height;
}
if (fAddressPane.isPaneVisible())
{
fAddressPane.setBounds(x, y, fAddressPane.computeSize(0, 0).x, Rendering.this.getBounds().height - y);
x = fAddressPane.getBounds().x + fAddressPane.getBounds().width;
}
if (fDataPane.isPaneVisible())
{
fDataPane.setBounds(x, y, fDataPane.computeSize(0, 0).x, Rendering.this.getBounds().height - y);
x = fDataPane.getBounds().x + fDataPane.getBounds().width;
}
ScrollBar horizontal = Rendering.this.getHorizontalBar();
horizontal.setVisible(true);
horizontal.setMinimum(0);
horizontal.setMaximum(fDataPane.getBounds().x + fDataPane.getBounds().width + xOffset);
@SuppressWarnings("unused")
int temp = horizontal.getMaximum();
horizontal.setThumb(getClientArea().width);
horizontal.setPageIncrement(40); // TODO ?
horizontal.setIncrement(20); // TODO ?
}
@Override
protected Point computeSize(Composite composite, int wHint, int hHint, boolean flushCache)
{
return new Point(100, 100); // dummy data
}
});
}
// Handles for the caret/cursor movement keys
protected void handleDownArrow()
{
fViewportAddress = fViewportAddress.add(BigInteger.valueOf(getAddressableCellsPerRow()));
ensureViewportAddressDisplayable();
redrawPanes();
}
protected void handleUpArrow()
{
fViewportAddress = fViewportAddress.subtract(BigInteger.valueOf(getAddressableCellsPerRow()));
ensureViewportAddressDisplayable();
redrawPanes();
}
protected void handlePageDown()
{
fViewportAddress = fViewportAddress.add(BigInteger.valueOf(getAddressableCellsPerRow() * (Rendering.this.getRowCount() - 1)));
ensureViewportAddressDisplayable();
redrawPanes();
}
protected void handlePageUp()
{
fViewportAddress = fViewportAddress.subtract(BigInteger.valueOf(getAddressableCellsPerRow() * (Rendering.this.getRowCount() - 1)));
ensureViewportAddressDisplayable();
redrawPanes();
}
protected SelectionListener createHorizontalBarSelectionListener()
{
return new SelectionListener()
{
@Override
public void widgetSelected(SelectionEvent se)
{
Rendering.this.layout();
}
@Override
public void widgetDefaultSelected(SelectionEvent se)
{
// Do nothing
}
};
}
protected SelectionListener createVerticalBarSelectinListener()
{
return new SelectionListener()
{
@Override
public void widgetSelected(SelectionEvent se)
{
switch (se.detail)
{
case SWT.ARROW_DOWN:
handleDownArrow();
break;
case SWT.PAGE_DOWN:
handlePageDown();
break;
case SWT.ARROW_UP:
handleUpArrow();
break;
case SWT.PAGE_UP:
handlePageUp();
break;
case SWT.SCROLL_LINE:
// See: BUG 203068 selection event details broken on GTK < 2.6
default:
{
if (getVerticalBar().getSelection() == getVerticalBar().getMinimum())
{
// Set view port start address to the start address of the Memory Block
fViewportAddress = Rendering.this.getMemoryBlockStartAddress();
}
else if (getVerticalBar().getSelection() == getVerticalBar().getMaximum())
{
// The view port end address should be less or equal to the the end address of the Memory Block
// Set view port address to be bigger than the end address of the Memory Block for now
// and let ensureViewportAddressDisplayable() to figure out the correct view port start address
fViewportAddress = Rendering.this.getMemoryBlockEndAddress();
}
else
{
// Figure out the delta, ignore events with no delta
int deltaScroll = getVerticalBar().getSelection() - fScrollSelection;
if (deltaScroll == 0) break;
BigInteger deltaRows = scrollbar2rows(deltaScroll);
BigInteger newAddress = fViewportAddress.add(BigInteger.valueOf(getAddressableCellsPerRow()).multiply(deltaRows));
fViewportAddress = newAddress;
}
ensureViewportAddressDisplayable();
// Update tooltip; FIXME conversion from slider to scrollbar
// getVerticalBar().setToolTipText(Rendering.this.getAddressString(fViewportAddress));
// Update the addresses in the Address pane.
if (fAddressPane.isPaneVisible())
fAddressPane.redraw();
redrawPanes();
break;
}
}
}
@Override
public void widgetDefaultSelected(SelectionEvent se)
{
// do nothing
}
};
}
protected FPAddressPane createAddressPane()
{
return new FPAddressPane(this);
}
protected FPDataPane createDataPane()
{
return new FPDataPane(this);
}
public FPRendering getFPRendering() // TODO rename
{
return fParent;
}
protected void setCaretAddress(BigInteger address)
{
fCaretAddress = address;
}
protected BigInteger getCaretAddress()
{
// Return the caret address if it has been set. Otherwise return the viewport address.
// When the rendering is first created, the caret is unset until the user clicks somewhere
// in the rendering. It also reset (unset) when the user gives us a new viewport address
return (fCaretAddress != null) ? fCaretAddress : fViewportAddress;
}
void doGoToAddress()
{
try
{
BigInteger address = fAddressBar.getGoToAddress(this.getMemoryBlockStartAddress(), this.getCaretAddress());
getFPRendering().gotoAddress(address);
setVisibleAddressBar(false);
}
catch (NumberFormatException e1)
{
// FIXME log?
}
}
// Ensure that all addresses displayed are within the addressable range
protected void ensureViewportAddressDisplayable()
{
if (fViewportAddress.compareTo(Rendering.this.getMemoryBlockStartAddress()) < 0)
{
fViewportAddress = Rendering.this.getMemoryBlockStartAddress();
}
else if (getViewportEndAddress().compareTo(getMemoryBlockEndAddress().add(BigInteger.ONE)) > 0)
{
fViewportAddress = getMemoryBlockEndAddress().subtract(BigInteger.valueOf(getAddressableCellsPerRow() * getRowCount() - 1));
}
setScrollSelection();
}
public FPIMemorySelection getSelection()
{
return fSelection;
}
protected int getHistoryDepth()
{
return fViewportCache.getHistoryDepth();
}
protected void setHistoryDepth(int depth)
{
fViewportCache.setHistoryDepth(depth);
}
public void logError(String message, Exception e)
{
Status status = new Status(IStatus.ERROR, fParent.getRenderingId(), DebugException.INTERNAL_ERROR, message, e);
FPRenderingPlugin.getDefault().getLog().log(status);
}
public void handleFontPreferenceChange(Font font)
{
setFont(font);
Control controls[] = this.getRenderingPanes();
for (int index = 0; index < controls.length; index++)
controls[index].setFont(font);
packColumns();
layout(true);
}
public void setPaddingString(String padding)
{
fPaddingString = padding;
refresh();
}
public char getPaddingCharacter()
{
return fPaddingString.charAt(0); // use only the first character
}
static int suspendCount = 0;
@Override
public void handleDebugEvents(DebugEvent[] events)
{
if (this.isDisposed()) return;
boolean isChangeOnly = false;
boolean isSuspend = false;
boolean isBreakpointHit = false;
for (int index = 0; index < events.length; index++)
{
if (events[0].getSource() instanceof IDebugElement)
{
final int kind = events[index].getKind();
final int detail = events[index].getDetail();
final IDebugElement source = (IDebugElement) events[index].getSource();
/*
* We have to make sure we are comparing memory blocks here. It pretty much is now the
* case that the IDebugTarget is always null. Almost no one in the Embedded Space is
* using anything but CDT/DSF or CDT/TCF at this point. The older CDI stuff will still
* be using the old Debug Model API. But this will generate the same memory block and
* a legitimate IDebugTarget which will match properly.
*/
if( source.equals( getMemoryBlock() ) && source.getDebugTarget() == getMemoryBlock().getDebugTarget() )
{
if ((detail & DebugEvent.BREAKPOINT) != 0) isBreakpointHit = true;
if (kind == DebugEvent.SUSPEND)
{
handleSuspendEvent(detail);
isSuspend = true;
}
else if (kind == DebugEvent.CHANGE)
{
handleChangeEvent();
isChangeOnly = true;
}
}
}
}
if (isSuspend)
handleSuspend(isBreakpointHit);
else if (isChangeOnly)
handleChange();
}
protected void handleSuspend(boolean isBreakpointHit)
{
if (getUpdateMode() == UPDATE_ALWAYS || (getUpdateMode() == UPDATE_ON_BREAKPOINT && isBreakpointHit))
{
Display.getDefault().asyncExec(new Runnable()
{
@Override
public void run()
{
archiveDeltas();
refresh();
}
});
}
}
protected void handleChange()
{
if (getUpdateMode() == UPDATE_ALWAYS)
{
Display.getDefault().asyncExec(new Runnable()
{
@Override
public void run()
{
refresh();
}
});
}
}
protected void handleSuspendEvent(int detail)
{
}
protected void handleChangeEvent()
{
}
// Return true to enable development debug print statements
public boolean isDebug()
{
return false;
}
protected IMemoryBlockExtension getMemoryBlock()
{
IMemoryBlock block = fParent.getMemoryBlock();
if (block != null)
return block.getAdapter(IMemoryBlockExtension.class);
return null;
}
public BigInteger getBigBaseAddress()
{
return fParent.getBigBaseAddress();
}
public int getAddressableSize()
{
return fParent.getAddressableSize();
}
protected FPIViewportCache getViewportCache()
{
return fViewportCache;
}
public FPMemoryByte[] getBytes(BigInteger address, int bytes) throws DebugException
{
return getViewportCache().getBytes(address, bytes);
}
// Default visibility for performance
ViewportCache fViewportCache = new ViewportCache();
private interface Request
{
}
class ViewportCache extends Thread implements FPIViewportCache
{
class ArchiveDeltas implements Request
{
}
class AddressPair implements Request
{
BigInteger startAddress;
BigInteger endAddress;
public AddressPair(BigInteger start, BigInteger end)
{
startAddress = start;
endAddress = end;
}
@Override
public boolean equals(Object obj)
{
if (obj == null)
return false;
if (obj instanceof AddressPair)
{
return ((AddressPair) obj).startAddress.equals(startAddress) && ((AddressPair) obj).endAddress.equals(endAddress);
}
return false;
}
@Override
public int hashCode() {
return super.hashCode() + startAddress.hashCode() + endAddress.hashCode();
}
}
class MemoryUnit implements Cloneable
{
BigInteger start;
BigInteger end;
FPMemoryByte[] bytes;
@Override
public MemoryUnit clone()
{
MemoryUnit b = new MemoryUnit();
b.start = this.start;
b.end = this.end;
b.bytes = new FPMemoryByte[this.bytes.length];
for (int index = 0; index < this.bytes.length; index++)
b.bytes[index] = new FPMemoryByte(this.bytes[index].getValue());
return b;
}
public boolean isValid()
{
return this.start != null && this.end != null && this.bytes != null;
}
}
@SuppressWarnings("hiding")
private HashMap<BigInteger, FPMemoryByte[]> fEditBuffer = new HashMap<>();
private boolean fDisposed = false;
private Object fLastQueued = null;
private Vector<Object> fQueue = new Vector<>();
protected MemoryUnit fCache = null;
protected MemoryUnit fHistoryCache[] = new MemoryUnit[0];
protected int fHistoryDepth = 0;
public ViewportCache()
{
start();
}
@Override
public void dispose()
{
fDisposed = true;
synchronized (fQueue)
{
fQueue.notify();
}
}
public int getHistoryDepth()
{
return fHistoryDepth;
}
public void setHistoryDepth(int depth)
{
fHistoryDepth = depth;
fHistoryCache = new MemoryUnit[fHistoryDepth];
}
@Override
public void refresh()
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
if (fCache != null)
{
queueRequest(fViewportAddress, getViewportEndAddress());
}
}
@Override
public void archiveDeltas()
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
if (fCache != null)
{
queueRequestArchiveDeltas();
}
}
private void queueRequest(BigInteger startAddress, BigInteger endAddress)
{
AddressPair pair = new AddressPair(startAddress, endAddress);
queue(pair);
}
private void queueRequestArchiveDeltas()
{
ArchiveDeltas archive = new ArchiveDeltas();
queue(archive);
}
private void queue(Object element)
{
synchronized (fQueue)
{
if (!(fQueue.size() > 0 && element.equals(fLastQueued)))
{
fQueue.addElement(element);
fLastQueued = element;
}
fQueue.notify();
}
}
@Override
public void run()
{
while (!fDisposed)
{
AddressPair pair = null;
boolean archiveDeltas = false;
synchronized (fQueue)
{
if (fQueue.size() > 0)
{
Request request = (Request) fQueue.elementAt(0);
Class<?> type = request.getClass();
while (fQueue.size() > 0 && type.isInstance(fQueue.elementAt(0)))
{
request = (Request) fQueue.elementAt(0);
fQueue.removeElementAt(0);
}
if (request instanceof ArchiveDeltas)
archiveDeltas = true;
else if (request instanceof AddressPair)
pair = (AddressPair) request;
}
}
if (archiveDeltas)
{
for (int i = fViewportCache.getHistoryDepth() - 1; i > 0; i--)
fHistoryCache[i] = fHistoryCache[i - 1];
fHistoryCache[0] = fCache.clone();
}
else if (pair != null)
{
populateCache(pair.startAddress, pair.endAddress);
}
else
{
synchronized (fQueue)
{
try
{
if (fQueue.isEmpty())
{
fQueue.wait();
}
} catch (Exception e)
{
// do nothing
}
}
}
}
}
// Cache memory necessary to paint viewport
// TODO: user setting to buffer +/- x lines
// TODO: reuse existing cache? probably only a minor performance gain
private void populateCache(final BigInteger startAddress, final BigInteger endAddress)
{
try
{
IMemoryBlockExtension memoryBlock = getMemoryBlock();
BigInteger lengthInBytes = endAddress.subtract(startAddress);
BigInteger addressableSize = BigInteger.valueOf(getAddressableSize());
long units = lengthInBytes.divide(addressableSize)
.add(lengthInBytes.mod(addressableSize).compareTo(BigInteger.ZERO) > 0 ? BigInteger.ONE : BigInteger.ZERO).longValue();
// CDT (and maybe other backends) will call setValue() on these MemoryBlock objects. We
// don't want this to happen, because it interferes with this rendering's own change history.
// Ideally, we should strictly use the back end change notification and history, but it is
// only guaranteed to work for bytes within the address range of the MemoryBlock.
MemoryByte readBytes[] = memoryBlock.getBytesFromAddress(startAddress, units);
FPMemoryByte cachedBytes[] = new FPMemoryByte[readBytes.length];
for (int index = 0; index < readBytes.length; index++)
cachedBytes[index] = new FPMemoryByte(readBytes[index].getValue(), readBytes[index].getFlags());
// Derive the target endian from the read MemoryBytes.
if (cachedBytes.length > 0)
if (cachedBytes[0].isEndianessKnown())
setTargetLittleEndian(!cachedBytes[0].isBigEndian());
// The first time we execute this method, set the display endianness to the target endianness.
if (!initialDisplayModeSet)
{
setDisplayLittleEndian(isTargetLittleEndian());
initialDisplayModeSet = true;
}
// Re-order bytes within unit to be a sequential byte stream if the endian is already little
if (isTargetLittleEndian())
{
// There isn't an order when the unit size is one, so skip for performance
if (addressableSize.compareTo(BigInteger.ONE) != 0)
{
int unitSize = addressableSize.intValue();
FPMemoryByte cachedBytesAsByteSequence[] = new FPMemoryByte[cachedBytes.length];
for (int unit = 0; unit < units; unit++)
{
for (int unitbyte = 0; unitbyte < unitSize; unitbyte++)
{
cachedBytesAsByteSequence[unit * unitSize + unitbyte] = cachedBytes[unit * unitSize + unitSize - unitbyte];
}
}
cachedBytes = cachedBytesAsByteSequence;
}
}
final FPMemoryByte[] cachedBytesFinal = cachedBytes;
fCache = new MemoryUnit();
fCache.start = startAddress;
fCache.end = endAddress;
fCache.bytes = cachedBytesFinal;
Display.getDefault().asyncExec(new Runnable()
{
@Override
public void run()
{
// Generate deltas
for (int historyIndex = 0; historyIndex < getHistoryDepth(); historyIndex++)
{
if (fHistoryCache[historyIndex] != null && fHistoryCache[historyIndex].isValid())
{
BigInteger maxStart = startAddress.max(fHistoryCache[historyIndex].start);
BigInteger minEnd = endAddress.min(fHistoryCache[historyIndex].end).subtract(BigInteger.ONE);
BigInteger overlapLength = minEnd.subtract(maxStart);
if (overlapLength.compareTo(BigInteger.valueOf(0)) > 0)
{
// there is overlap
int offsetIntoOld = maxStart.subtract(fHistoryCache[historyIndex].start).intValue();
int offsetIntoNew = maxStart.subtract(startAddress).intValue();
for (int i = overlapLength.intValue(); i >= 0; i--)
{
cachedBytesFinal[offsetIntoNew + i].setChanged(historyIndex,
cachedBytesFinal[offsetIntoNew + i].getValue() != fHistoryCache[historyIndex].bytes[offsetIntoOld + i]
.getValue());
}
// There are several scenarios where the history cache must be updated from the data cache, so that when a
// cell is edited the font color changes appropriately. The following code deals with the different cases.
if (historyIndex != 0) continue;
int dataStart = fCache.start.intValue();
int dataEnd = fCache.end.intValue();
int dataLength = fCache.bytes.length;
int historyStart = fHistoryCache[0].start.intValue();
int historyEnd = fHistoryCache[0].end.intValue();
int historyLength = fHistoryCache[0].bytes.length;
// Case 1: The data cache is smaller than the history cache; the data cache's
// address range is fully covered by the history cache. Do nothing.
if ((dataStart >= historyStart) && (dataEnd <= historyEnd))
continue;
// Case 2: The data and history cache's do not overlap at all
if (((dataStart < historyStart) && (dataEnd < historyStart)) || (dataStart > historyEnd))
{
// Create a new history cache: Copy the data cache bytes to the history cache
MemoryUnit newHistoryCache = new MemoryUnit();
newHistoryCache.start = fCache.start;
newHistoryCache.end = fCache.end;
int newHistoryCacheSize = fCache.bytes.length;
newHistoryCache.bytes = new FPMemoryByte[newHistoryCacheSize];
for (int index = 0; index < newHistoryCacheSize; index++)
newHistoryCache.bytes[index] = new FPMemoryByte(fCache.bytes[index].getValue());
fHistoryCache[0] = newHistoryCache;
continue;
}
// Case 3: The data cache starts at a lower address than the history cache, but overlaps the history cache
if ((dataStart < historyStart) && ((dataEnd >= historyStart) && (dataEnd <= historyEnd)))
{
// Create a new history cache with the missing data from the main cache and append the old history to it.
int missingDataByteCount = historyStart - dataStart;
int historyCacheSize = historyLength;
int newHistoryCacheSize = missingDataByteCount + historyLength;
if (missingDataByteCount <= 0 && historyCacheSize <= 0) break;
MemoryUnit newHistoryCache = new MemoryUnit();
newHistoryCache.start = fCache.start;
newHistoryCache.end = fHistoryCache[0].end;
newHistoryCache.bytes = new FPMemoryByte[newHistoryCacheSize];
// Copy the missing bytes from the beginning of the main cache to the history cache.
for (int index = 0; index < missingDataByteCount; index++)
newHistoryCache.bytes[index] = new FPMemoryByte(fCache.bytes[index].getValue());
// Copy the remaining bytes from the old history cache to the new history cache
for (int index = 0; index < historyCacheSize; index++)
newHistoryCache.bytes[index + missingDataByteCount] =
new FPMemoryByte(fHistoryCache[0].bytes[index].getValue());
fHistoryCache[0] = newHistoryCache;
continue;
}
// Case 4: The data cache starts at a higher address than the history cache
if (((dataStart >= historyStart) && (dataStart <= historyEnd)) && (dataEnd > historyEnd))
{
// Append the missing main cache bytes to the history cache.
int missingDataByteCount = dataEnd - historyEnd;
int historyCacheSize = historyEnd - historyStart;
int newHistoryCacheSize = missingDataByteCount + historyLength;
if (missingDataByteCount > 0 && historyCacheSize > 0)
{
MemoryUnit newHistoryCache = new MemoryUnit();
newHistoryCache.start = fHistoryCache[0].start;
newHistoryCache.end = fCache.end;
newHistoryCache.bytes = new FPMemoryByte[newHistoryCacheSize];
// Copy the old history bytes to the new history cache
System.arraycopy(fHistoryCache[0].bytes, 0, newHistoryCache.bytes, 0, historyLength);
// Copy the bytes from the main cache that are not in the history cache to the end of the new history cache.
for (int index = 0; index < missingDataByteCount; index++)
{
int srcIndex = dataLength - missingDataByteCount + index;
int dstIndex = historyLength + index;
newHistoryCache.bytes[dstIndex] = new FPMemoryByte(fCache.bytes[srcIndex].getValue());
}
fHistoryCache[0] = newHistoryCache;
continue;
}
}
// Case 5 - The data cache is greater than the history cache and fully covers it
if (dataStart < historyStart && dataEnd > historyEnd)
{
int start = 0;
int end = 0;
// Create a new history cache to reflect the entire data cache
MemoryUnit newHistoryCache = new MemoryUnit();
newHistoryCache.start = fCache.start;
newHistoryCache.end = fCache.end;
int newHistoryCacheSize = fCache.bytes.length;
newHistoryCache.bytes = new FPMemoryByte[newHistoryCacheSize];
int topByteCount = historyStart - dataStart;
int bottomByteCount = dataEnd - historyEnd;
// Copy the bytes from the beginning of the data cache to the new history cache
for (int index = 0; index < topByteCount; index++)
newHistoryCache.bytes[index] = new FPMemoryByte(fCache.bytes[index].getValue());
// Copy the old history cache bytes to the new history cache
start = topByteCount;
end = topByteCount + historyLength;
for (int index = start; index < end; index++)
newHistoryCache.bytes[index] = new FPMemoryByte(fCache.bytes[index].getValue());
// Copy the bytes from the end of the data cache to the new history cache
start = topByteCount + historyLength;
end = topByteCount + historyLength + bottomByteCount;
for (int index = start; index < end; index++)
newHistoryCache.bytes[index] = new FPMemoryByte(fCache.bytes[index].getValue());
fHistoryCache[0] = newHistoryCache;
continue;
}
}
}
}
// If the history does not exist, populate the history with the just populated
// cache. This solves the use case of (1) connect to target; (2) edit memory
// before the first suspend debug event; (3) paint differences in changed color.
if (fHistoryCache[0] == null)
fHistoryCache[0] = fCache.clone();
Rendering.this.redrawPanes();
}
});
}
catch (Exception e)
{
// User can scroll to any memory, whether it's valid on the target or not. It doesn't make
// much sense to fill up the Eclipse error log with such "failures." So, comment out for now.
// logError(FPRenderingMessages.getString("FAILURE_READ_MEMORY"), e); //$NON-NLS-1$
}
}
// Bytes will be fetched from cache
@Override
public FPMemoryByte[] getBytes(BigInteger address, int bytesRequested) throws DebugException
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
if (containsEditedCell(address)) // Cell size cannot be switched during an edit
return getEditedMemory(address);
boolean contains = false;
if (fCache != null && fCache.start != null)
{
// See if all of the data requested is in the cache
BigInteger dataEnd = address.add(BigInteger.valueOf(bytesRequested));
if (fCache.start.compareTo(address) <= 0 && fCache.end.compareTo(dataEnd) >= 0 && fCache.bytes.length > 0)
contains = true;
}
if (contains)
{
int offset = address.subtract(fCache.start).intValue();
FPMemoryByte bytes[] = new FPMemoryByte[bytesRequested];
for (int index = 0; index < bytes.length; index++)
bytes[index] = fCache.bytes[offset + index];
return bytes;
}
FPMemoryByte bytes[] = new FPMemoryByte[bytesRequested];
for (int index = 0; index < bytes.length; index++)
{
bytes[index] = new FPMemoryByte();
bytes[index].setReadable(false);
}
fViewportCache.queueRequest(fViewportAddress, getViewportEndAddress());
return bytes;
}
@Override
public boolean containsEditedCell(BigInteger address)
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
return fEditBuffer.containsKey(address);
}
public FPMemoryByte[] getEditedMemory(BigInteger address)
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
return fEditBuffer.get(address);
}
@Override
public void clearEditBuffer()
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
fEditBuffer.clear();
Rendering.this.redrawPanes();
}
@Override
public void writeEditBuffer()
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
Set<BigInteger> keySet = fEditBuffer.keySet();
Iterator<BigInteger> iterator = keySet.iterator();
while (iterator.hasNext())
{
BigInteger address = iterator.next();
FPMemoryByte[] bytes = fEditBuffer.get(address);
byte byteValue[] = new byte[bytes.length];
for (int index = 0; index < bytes.length; index++)
byteValue[index] = bytes[index].getValue();
try
{
IMemoryBlockExtension block = getMemoryBlock();
BigInteger offset = address.subtract(block.getBigBaseAddress());
block.setValue(offset, byteValue);
}
catch (Exception e)
{
MemoryViewUtil.openError(FPRenderingMessages.getString("FAILURE_WRITE_MEMORY"), "", e); //$NON-NLS-1$ //$NON-NLS-2$
logError(FPRenderingMessages.getString("FAILURE_WRITE_MEMORY"), e); //$NON-NLS-1$
}
}
clearEditBuffer();
}
@Override
public void setEditedValue(BigInteger address, FPMemoryByte[] bytes)
{
assert Thread.currentThread().equals(Display.getDefault().getThread()) : FPRenderingMessages.getString("CALLED_ON_NON_DISPATCH_THREAD"); //$NON-NLS-1$
fEditBuffer.put(address, bytes);
Rendering.this.redrawPanes();
}
}
public void setVisibleAddressBar(boolean visible)
{
fAddressBarControl.setVisible(visible);
if (visible)
{
String selectedStr = "0x" + getCaretAddress().toString(16); //$NON-NLS-1$
Text text = fAddressBar.getExpressionWidget();
text.setText(selectedStr);
text.setSelection(0, text.getCharCount());
fAddressBar.getExpressionWidget().setFocus();
}
layout(true);
layoutPanes();
}
public void setDirty(boolean needRefresh)
{
fCacheDirty = needRefresh;
}
public boolean isDirty()
{
return fCacheDirty;
}
@Override
public void dispose()
{
DebugPlugin.getDefault().removeDebugEventListener(this);
if (fViewportCache != null)
{
fViewportCache.dispose();
fViewportCache = null;
}
super.dispose();
}
class Selection implements FPIMemorySelection
{
private BigInteger fStartHigh = null;
private BigInteger fStartLow = null;
private BigInteger fEndHigh = null;
private BigInteger fEndLow = null;
@Override
public void clear()
{
fEndHigh = fEndLow = fStartHigh = fStartLow = null;
redrawPanes();
}
@Override
public boolean hasSelection()
{
return fStartHigh != null && fStartLow != null && fEndHigh != null && fEndLow != null;
}
@Override
public boolean isSelected(BigInteger address)
{
// Do we have valid start and end addresses?
if (getEnd() == null || getStart() == null) return false;
// If end is greater than start
if (getEnd().compareTo(getStart()) >= 0)
{
// If address is greater-than-or-equal-to start and less then end, return true
if (address.compareTo(getStart()) >= 0 && address.compareTo(getEnd()) < 0) return true;
}
// If start is greater than end
else if (getStart().compareTo(getEnd()) >= 0)
{
// If address is greater-than-or-equal-to zero and less than start, return true
if (address.compareTo(getEnd()) >= 0 && address.compareTo(getStart()) < 0) return true;
}
return false;
}
// Set selection start
@Override
public void setStart(BigInteger high, BigInteger low)
{
if (high == null && low == null)
{
if (fStartHigh != null && fStartLow != null)
{
fStartHigh = null;
fStartLow = null;
redrawPanes();
}
return;
}
boolean changed = false;
if (fStartHigh == null || !high.equals(fStartHigh))
{
fStartHigh = high;
changed = true;
}
if (fStartLow == null || !low.equals(fStartLow))
{
fStartLow = low;
changed = true;
}
if (changed) redrawPanes();
}
// Set selection end
@Override
public void setEnd(BigInteger high, BigInteger low)
{
if (high == null && low == null)
{
if (fEndHigh != null && fEndLow != null)
{
fEndHigh = null;
fEndLow = null;
redrawPanes();
}
return;
}
boolean changed = false;
if (fEndHigh == null || !high.equals(fEndHigh))
{
fEndHigh = high;
changed = true;
}
if (fEndLow == null || !low.equals(fEndLow))
{
fEndLow = low;
changed = true;
}
if (changed) redrawPanes();
}
@Override
public BigInteger getHigh()
{
if (!hasSelection()) return null;
return getStart().max(getEnd());
}
@Override
public BigInteger getLow()
{
if (!hasSelection()) return null;
return getStart().min(getEnd());
}
@Override
public BigInteger getStart()
{
// If there is no start, return null
if (fStartHigh == null) return null;
// If there is no end, return the high address of the start
if (fEndHigh == null) return fStartHigh;
// If Start High/Low equal End High/Low, return a low start and high end
if (fStartHigh.equals(fEndHigh) && fStartLow.equals(fEndLow)) return fStartLow;
BigInteger differenceEndToStartHigh = fEndHigh.subtract(fStartHigh).abs();
BigInteger differenceEndToStartLow = fEndHigh.subtract(fStartLow).abs();
// Return the start high or start low based on which creates a larger selection
if (differenceEndToStartHigh.compareTo(differenceEndToStartLow) > 0)
return fStartHigh;
return fStartLow;
}
@Override
public BigInteger getStartLow()
{
return fStartLow;
}
@Override
public BigInteger getEnd()
{
// If there is no end, return null
if (fEndHigh == null) return null;
// *** Temporary for debugging ***
if (fStartHigh == null || fStartLow == null)
{
return null;
}
// If Start High/Low equal End High/Low, return a low start and high end
if (fStartHigh.equals(fEndHigh) && fStartLow.equals(fEndLow)) return fStartHigh;
BigInteger differenceStartToEndHigh = fStartHigh.subtract(fEndHigh).abs();
BigInteger differenceStartToEndLow = fStartHigh.subtract(fEndLow).abs();
// Return the start high or start low based on which creates a larger selection
if (differenceStartToEndHigh.compareTo(differenceStartToEndLow) >= 0)
return fEndHigh;
return fEndLow;
}
}
public void setPaneVisible(int pane, boolean visible)
{
switch (pane)
{
case PANE_ADDRESS:
fAddressPane.setPaneVisible(visible);
break;
case PANE_DATA:
fDataPane.setPaneVisible(visible);
break;
}
fireSettingsChanged();
layoutPanes();
}
public boolean getPaneVisible(int pane)
{
switch (pane)
{
case PANE_ADDRESS:
return fAddressPane.isPaneVisible();
case PANE_DATA:
return fDataPane.isPaneVisible();
default:
return false;
}
}
protected void packColumns()
{
int availableWidth = Rendering.this.getSize().x;
if (fAddressPane.isPaneVisible())
{
availableWidth -= fAddressPane.computeSize(0, 0).x;
availableWidth -= Rendering.this.getRenderSpacing() * 2;
}
int combinedWidth = 0;
if (fDataPane.isPaneVisible()) combinedWidth += fDataPane.getCellWidth();
if (getColumnsSetting() == Rendering.COLUMNS_AUTO_SIZE_TO_FIT)
{
if (combinedWidth == 0)
fColumnCount = 0;
else
{
fColumnCount = availableWidth / combinedWidth;
if (fColumnCount == 0) fColumnCount = 1; // Paint one column even if only part can show in view
}
}
else
fColumnCount = getColumnsSetting();
try
{
// Update the number of bytes per row; the max/min scroll range and the current thumbnail position.
fBytesPerRow = getCharsPerColumn() * getColumnCount();
getVerticalBar().setMinimum(1);
// scrollbar maximum range is Integer.MAX_VALUE.
getVerticalBar().setMaximum(getMaxScrollRange().min(BigInteger.valueOf(Integer.MAX_VALUE)).intValue());
getVerticalBar().setIncrement(1);
getVerticalBar().setPageIncrement(this.getRowCount() - 1);
// FIXME: conversion of slider to scrollbar
// fScrollBar.setToolTipText(Rendering.this.getAddressString(fViewportAddress));
setScrollSelection();
}
catch (Exception e)
{
// FIXME precautionary
}
Rendering.this.redraw();
Rendering.this.redrawPanes();
}
public FPAbstractPane[] getRenderingPanes()
{
return new FPAbstractPane[] { fAddressPane, fDataPane };
}
public int getCellPadding()
{
return fCellPadding;
}
protected int getRenderSpacing()
{
return fPaneSpacing;
}
public void refresh()
{
if (!this.isDisposed())
{
if (this.isVisible() && getViewportCache() != null)
{
getViewportCache().refresh();
}
else
{
setDirty(true);
fParent.updateRenderingLabels();
}
}
}
protected void archiveDeltas()
{
this.getViewportCache().archiveDeltas();
}
public void gotoAddress(BigInteger address)
{
// Ensure that the GoTo address is within the addressable range
if ((address.compareTo(this.getMemoryBlockStartAddress()) < 0) || (address.compareTo(this.getMemoryBlockEndAddress()) > 0))
return;
fViewportAddress = address;
// Reset the caret and selection state (no caret and no selection)
fCaretAddress = null;
fSelection = new Selection();
redrawPanes();
}
public void setViewportStartAddress(BigInteger newAddress)
{
fViewportAddress = newAddress;
}
public BigInteger getViewportStartAddress()
{
return fViewportAddress;
}
public BigInteger getViewportEndAddress()
{
return fViewportAddress.add(BigInteger.valueOf(this.getBytesPerRow() * getRowCount() / getAddressableSize()));
}
public String getAddressString(BigInteger address)
{
StringBuffer addressString = new StringBuffer(address.toString(16).toUpperCase());
for (int chars = getAddressBytes() * 2 - addressString.length(); chars > 0; chars--)
addressString.insert(0, '0');
addressString.insert(0, "0x"); //$NON-NLS-1$
return addressString.toString();
}
protected int getAddressBytes()
{
return fParent.getAddressSize();
}
public Control getAddressBarControl()
{
return fAddressBarControl;
}
public int getColumnCount()
{
return fColumnCount;
}
public int getColumnsSetting()
{
return fColumnsSetting;
}
protected void setBytesPerRow(int count)
{
fBytesPerRow = count;
}
protected void setColumnCount(int count)
{
fColumnCount = count;
}
public void setColumnsSetting(int columns)
{
if (fColumnsSetting != columns)
{
fColumnsSetting = columns;
fireSettingsChanged();
layoutPanes();
}
}
protected void ensureVisible(BigInteger address)
{
BigInteger viewportStart = this.getViewportStartAddress();
BigInteger viewportEnd = this.getViewportEndAddress();
boolean isAddressBeforeViewportStart = address.compareTo(viewportStart) < 0;
boolean isAddressAfterViewportEnd = address.compareTo(viewportEnd) > 0;
if (isAddressBeforeViewportStart || isAddressAfterViewportEnd) gotoAddress(address);
}
protected int getRowCount()
{
int rowCount = 0;
Control panes[] = getRenderingPanes();
for (int i = 0; i < panes.length; i++)
if (panes[i] instanceof FPAbstractPane)
rowCount = Math.max(rowCount, ((FPAbstractPane) panes[i]).getRowCount());
return rowCount;
}
protected int getBytesPerRow()
{
return fBytesPerRow;
}
protected int getAddressableCellsPerRow()
{
return getBytesPerRow() / getAddressableSize();
}
public int getAddressesPerColumn()
{
return this.getCharsPerColumn() / getAddressableSize();
}
/**
* @return Set current scroll selection
*/
protected void setScrollSelection()
{
BigInteger selection = getViewportStartAddress().divide(BigInteger.valueOf(getAddressableCellsPerRow()));
fScrollSelection = rows2scrollbar(selection);
getVerticalBar().setSelection(fScrollSelection);
}
/**
* compute the maximum scrolling range.
*
* @return number of lines that rendering can display
*/
private BigInteger getMaxScrollRange()
{
BigInteger difference = getMemoryBlockEndAddress().subtract(getMemoryBlockStartAddress()).add(BigInteger.ONE);
BigInteger maxScrollRange = difference.divide(BigInteger.valueOf(getAddressableCellsPerRow()));
if (maxScrollRange.multiply(BigInteger.valueOf(getAddressableCellsPerRow())).compareTo(difference) != 0)
maxScrollRange = maxScrollRange.add(BigInteger.ONE);
// Support targets with an addressable size greater than 1
maxScrollRange = maxScrollRange.divide(BigInteger.valueOf(getAddressableSize()));
return maxScrollRange;
}
/**
* The scroll range is limited by SWT. Because it can be less than the number
* of rows (of memory) that we need to display, we need an arithmetic mapping.
*
* @return ratio this function returns how many rows a scroll bar unit
* represents. The number will be some fractional value, up to but
* not exceeding the value 1. I.e., when the scroll range exceeds
* the row range, we use a 1:1 mapping.
*/
private final BigDecimal getScrollRatio()
{
BigInteger maxRange = getMaxScrollRange();
if (maxRange.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0)
{
return new BigDecimal(maxRange).divide(BigDecimal.valueOf(Integer.MAX_VALUE), SCROLL_CONVERSION_PRECISION);
}
return BigDecimal.ONE;
}
/**
* Convert memory row units to scroll bar units. The scroll range is limited
* by SWT. Because it can be less than the number of rows (of memory) that
* we need to display, we need an arithmetic mapping.
*
* @param rows
* units of memory
* @return scrollbar units
*/
private int rows2scrollbar(BigInteger rows)
{
return new BigDecimal(rows).divide(getScrollRatio(), SCROLL_CONVERSION_PRECISION).intValue();
}
/**
* Convert scroll bar units to memory row units. The scroll range is limited
* by SWT. Because it can be less than the number of rows (of memory) that
* we need to display, we need an arithmetic mapping.
*
* @param scrollbarUnits
* scrollbar units
* @return number of rows of memory
*/
BigInteger scrollbar2rows(int scrollbarUnits)
{
return getScrollRatio().multiply(BigDecimal.valueOf(scrollbarUnits), SCROLL_CONVERSION_PRECISION).toBigInteger();
}
/**
* @return start address of the memory block
*/
protected BigInteger getMemoryBlockStartAddress()
{
if (fMemoryBlockStartAddress == null)
fMemoryBlockStartAddress = fParent.getMemoryBlockStartAddress();
if (fMemoryBlockStartAddress == null)
fMemoryBlockStartAddress = BigInteger.ZERO;
return fMemoryBlockStartAddress;
}
/**
* @return end address of the memory block
*/
protected BigInteger getMemoryBlockEndAddress()
{
if (fMemoryBlockEndAddress == null)
fMemoryBlockEndAddress = fParent.getMemoryBlockEndAddress();
return fMemoryBlockEndAddress;
}
public FPDataType getFPDataType()
{
return fFPDataType;
}
public void setFPDataType(FPDataType numberType)
{
if (fFPDataType == numberType) return;
fFPDataType = numberType;
fireSettingsChanged();
layoutPanes();
}
public int getUpdateMode()
{
return fUpdateMode;
}
public void setUpdateMode(int fUpdateMode)
{
this.fUpdateMode = fUpdateMode;
}
protected String getCharacterSet(int mode)
{
switch (mode)
{
case Rendering.TEXT_UTF8:
return "UTF8"; //$NON-NLS-1$
case Rendering.TEXT_UTF16:
return "UTF16"; //$NON-NLS-1$
case Rendering.TEXT_USASCII:
return "US-ASCII"; //$NON-NLS-1$
case Rendering.TEXT_ISO_8859_1:
default:
return "ISO-8859-1"; //$NON-NLS-1$
}
}
public int getBytesPerCharacter()
{
return 1;
}
public boolean isTargetLittleEndian()
{
return fIsTargetLittleEndian;
}
public void setTargetLittleEndian(boolean littleEndian)
{
if (fIsTargetLittleEndian == littleEndian) return;
fParent.setTargetMemoryLittleEndian(littleEndian);
fIsTargetLittleEndian = littleEndian;
Display.getDefault().asyncExec(new Runnable()
{
@Override
public void run()
{
fireSettingsChanged();
layoutPanes();
}
});
}
public boolean isDisplayLittleEndian()
{
return fIsDisplayLittleEndian;
}
public void setDisplayLittleEndian(boolean isLittleEndian)
{
if (fIsDisplayLittleEndian == isLittleEndian) return;
fIsDisplayLittleEndian = isLittleEndian;
fireSettingsChanged();
Display.getDefault().asyncExec(new Runnable()
{
@Override
public void run()
{
layoutPanes();
}
});
}
public int getCharsPerColumn()
{
return fCharsPerColumn;
}
public int getDisplayedPrecision()
{
return fDisplayedPrecision;
}
// Set the number of precision digits that are displayed in the view
public void setDisplayedPrecision(int displayedPrecision)
{
if (fDisplayedPrecision != displayedPrecision)
{
fDisplayedPrecision = displayedPrecision;
fCharsPerColumn = charsPerColumn();
fireSettingsChanged();
layoutPanes();
}
}
protected void redrawPane(int paneId)
{
if (!isDisposed() && this.isVisible())
{
FPAbstractPane pane = null;
if (paneId == Rendering.PANE_ADDRESS)
{
pane = fAddressPane;
}
else if (paneId == Rendering.PANE_DATA)
{
pane = fDataPane;
}
if (pane != null && pane.isPaneVisible())
{
pane.redraw();
pane.setRowCount();
if (pane.isFocusControl()) pane.updateTheCaret();
}
}
fParent.updateRenderingLabels();
}
protected void redrawPanes()
{
if (!isDisposed() && this.isVisible())
{
if (fAddressPane.isPaneVisible())
{
fAddressPane.redraw();
fAddressPane.setRowCount();
if (fAddressPane.isFocusControl()) fAddressPane.updateTheCaret();
}
if (fDataPane.isPaneVisible())
{
fDataPane.redraw();
fDataPane.setRowCount();
if (fDataPane.isFocusControl()) fDataPane.updateTheCaret();
}
}
fParent.updateRenderingLabels();
}
void layoutPanes()
{
packColumns();
layout(true);
redraw();
redrawPanes();
}
void fireSettingsChanged()
{
fAddressPane.settingsChanged();
fDataPane.settingsChanged();
}
protected void copyAddressToClipboard()
{
Clipboard clip = null;
try
{
clip = new Clipboard(getDisplay());
String addressString = "0x" + getCaretAddress().toString(16); //$NON-NLS-1$
TextTransfer plainTextTransfer = TextTransfer.getInstance();
clip.setContents(new Object[] { addressString }, new Transfer[] { plainTextTransfer });
}
finally
{
if (clip != null)
{
clip.dispose();
}
}
}
// Given an array of bytes, the data type and endianness, return a scientific notation string representation
public String sciNotationString(FPMemoryByte byteArray[], FPDataType fpDataType, boolean isLittleEndian)
{
StringBuffer textString = null;
// Check the byte array for readability
for (int index = 0; index < byteArray.length; index++)
if (!byteArray[index].isReadable())
return FPutilities.fillString(fCharsPerColumn, '?');
// Convert the byte array to a floating point value and check to see if it's within the range
// of the data type. If the valid range is exceeded, set string to "-Infinity" or "Infinity".
ByteOrder byteOrder = isLittleEndian ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN;
if (fpDataType == FPDataType.FLOAT)
{
float floatValue = ByteBuffer.wrap(FPutilities.memoryBytesToByteArray(byteArray)).order(byteOrder).getFloat();
floatValue = FPutilities.floatLimitCheck(floatValue);
if (floatValue == Float.NEGATIVE_INFINITY)
textString = new StringBuffer("-Infinity"); //$NON-NLS-1$
if (floatValue == Float.POSITIVE_INFINITY)
textString = new StringBuffer(" Infinity"); //$NON-NLS-1$
}
if (fpDataType == FPDataType.DOUBLE)
{
double doubleValue = ByteBuffer.wrap(FPutilities.memoryBytesToByteArray(byteArray)).order(byteOrder).getDouble();
doubleValue = FPutilities.doubleLimitCheck(doubleValue);
if (doubleValue == Double.NEGATIVE_INFINITY)
textString = new StringBuffer("-Infinity"); //$NON-NLS-1$
if (doubleValue == Double.POSITIVE_INFINITY)
textString = new StringBuffer(" Infinity"); //$NON-NLS-1$
}
// If we do not already have a StringBuffer value, Convert the value to
// a string. In any case, pad the string with spaces to the cell width.
if (textString == null)
textString = new StringBuffer(FPutilities.byteArrayToSciNotation(fpDataType, isLittleEndian, byteArray, fDisplayedPrecision));
return (textString.append(FPutilities.fillString(fCharsPerColumn - textString.length(), getPaddingCharacter()))).toString();
}
// Convert the floating point edit buffer string to a byte array and update memory
public void convertAndUpdateCell(BigInteger memoryAddress, String editBuffer)
{
if (editBuffer != null && editBuffer.length() > 0)
{
// Convert the edit buffer string to byte arrays
byte[] targetByteArray = new byte[getFPDataType().getByteLength()];
targetByteArray = FPutilities.floatingStringToByteArray(getFPDataType(), editBuffer, getFPDataType().getBitsize());
// If we're in little endian mode, reverse the bytes, which is required
// due to lower-level internal conversion when written to memory.
if (fIsDisplayLittleEndian)
targetByteArray = FPutilities.reverseByteOrder(targetByteArray);
FPMemoryByte[] newMemoryBytes = new FPMemoryByte[targetByteArray.length];
for (int index = 0; index < targetByteArray.length; index++)
{
newMemoryBytes[index] = new FPMemoryByte(targetByteArray[index]);
newMemoryBytes[index].setBigEndian(!isTargetLittleEndian());
newMemoryBytes[index].setEdited(true);
newMemoryBytes[index].setChanged(true);
}
// Apply the change and make it visible in the view
getViewportCache().setEditedValue(memoryAddress, newMemoryBytes);
getViewportCache().writeEditBuffer();
redraw();
}
else
{
// The edit buffer string is null or has a zero length.
final String errorText = NLS.bind(FPRenderingMessages.getString("FPRendering.ERROR_FPENTRY_POPUP_TEXT"), "<blanks>"); //$NON-NLS-1$ //$NON-NLS-2$
try
{
// Restore the previous value
setEditBuffer(new StringBuffer(fDataPane.bytesToSciNotation(getBytes(fCaretAddress, getFPDataType().getByteLength()))));
}
catch (DebugException e)
{
e.printStackTrace();
}
// Put together the pop-up window components and show the user the error
String statusString = FPRenderingMessages.getString("FPRendering.ERROR_FPENTRY_STATUS"); //$NON-NLS-1$
Status status = new Status(IStatus.ERROR, FPRenderingPlugin.getUniqueIdentifier(), statusString);
FPutilities.popupMessage(FPRenderingMessages.getString("FPRendering.ERROR_FPENTRY_POPUP_TITLE"), errorText, status); //$NON-NLS-1$
}
}
// Getter/setter for Insert Mode state
public void setInsertMode(boolean insertMode)
{
this.fEditInserMode = insertMode;
}
public boolean insertMode()
{
return fEditInserMode;
}
// Getter/setter for cell edit state: true = we're in cell edit mode; false = we're not in cell edit mode
public boolean isEditingCell()
{
return fCellEditState;
}
public void setEditingCell(boolean state)
{
this.fCellEditState = state;
}
// Getter/setter for the address of the cell currently being edited
public BigInteger getCellEditAddress()
{
return cellEditAddress;
}
public void setCellEditAddress(BigInteger cellEditAddress)
{
this.cellEditAddress = cellEditAddress;
}
// Getter/Setter for the memory address of the cell currently being edited
public BigInteger getMemoryAddress()
{
return memoryAddress;
}
public void setMemoryAddress(BigInteger memoryAddress)
{
this.memoryAddress = memoryAddress;
}
// Getter/setter for storing the raw/uninterpreted/not-converted-to-scientific-notation text entry string
public StringBuffer getEditBuffer()
{
return fEditBuffer;
}
public void setEditBuffer(StringBuffer cellChars)
{
this.fEditBuffer = cellChars;
}
// Enter cell-edit mode
public void startCellEditing(BigInteger cellAddress, BigInteger memoryAddress, String editString)
{
setEditBuffer(new StringBuffer(editString));
setCellEditAddress(cellAddress);
setMemoryAddress(memoryAddress);
setEditingCell(true);
}
// Exit cell-edit mode
public void endCellEditing()
{
setEditingCell(false);
setCellEditAddress(null);
setMemoryAddress(null);
setEditBuffer(null);
}
// Floating point number edit mode status-line display: 'true' = display edit mode, 'false' clear edit mode
public void displayEditModeIndicator(final boolean indicatorON)
{
UIJob job = new UIJob("FP Renderer Edit Indicator") //$NON-NLS-1$
{
@Override
public IStatus runInUIThread(IProgressMonitor monitor)
{
String statusLineMessage;
IViewPart viewInstance = null;
if (indicatorON)
{
// Construct the edit mode message
statusLineMessage = NLS.bind(FPRenderingMessages.getString("FPRendering.EDIT_MODE"), //$NON-NLS-1$
(insertMode() ? FPRenderingMessages.getString("FPRendering.EDIT_MODE_INSERT") : //$NON-NLS-1$
FPRenderingMessages.getString("FPRendering.EDIT_MODE_OVERWRITE"))); //$NON-NLS-1$
}
else
{
// 'null' = clear the message
statusLineMessage = null;
}
// Get the window and page references
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (window == null) return Status.OK_STATUS;
IWorkbenchPage page = window.getActivePage();
if (page == null) return Status.OK_STATUS;
// Update (or clear) the Workbench status line when the Memory and Memory Browser views are in focus
viewInstance = page.findView("org.eclipse.debug.ui.MemoryView"); // TODO: programmatically retrieve ID //$NON-NLS-1$
if (viewInstance != null)
viewInstance.getViewSite().getActionBars().getStatusLineManager().setMessage(statusLineMessage);
viewInstance = page.findView("org.eclipse.cdt.debug.ui.memory.memorybrowser.MemoryBrowser"); // TODO: programmatically retrieve ID //$NON-NLS-1$
if (viewInstance != null)
viewInstance.getViewSite().getActionBars().getStatusLineManager().setMessage(statusLineMessage);
return Status.OK_STATUS;
}
};
job.setSystem(true);
job.schedule();
}
// Calculate memory address from the cell address
public BigInteger cellToMemoryAddress(BigInteger cellAddress)
{
BigInteger vpStart = getViewportStartAddress();
BigInteger colChars = BigInteger.valueOf(getCharsPerColumn());
BigInteger dtBytes = BigInteger.valueOf(getFPDataType().getByteLength());
return vpStart.add(((cellAddress.subtract(vpStart)).divide(colChars)).multiply(dtBytes));
}
}