| /* |
| * Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| |
| package sun.jvm.hotspot.ui; |
| |
| import java.math.*; |
| import java.awt.*; |
| import java.awt.font.*; |
| import java.awt.geom.*; |
| import java.awt.event.*; |
| import java.io.*; |
| import javax.swing.*; |
| import javax.swing.event.*; |
| import java.util.*; |
| |
| import sun.jvm.hotspot.debugger.*; |
| import sun.jvm.hotspot.debugger.dummy.*; |
| import sun.jvm.hotspot.utilities.*; |
| |
| /** A subclass of JPanel which displays a hex dump of memory along |
| with annotations describing the significance of various |
| pieces. This can be used to implement either a stack or heap |
| inspector. */ |
| |
| public class AnnotatedMemoryPanel extends JPanel { |
| private boolean is64Bit; |
| private Debugger debugger; |
| private long addressSize; |
| private HighPrecisionJScrollBar scrollBar; |
| private Font font; |
| private int bytesPerLine; |
| private int paintCount; |
| private String unmappedAddrString; |
| // Type of this is an IntervalTree indexed by Interval<Address> and |
| // with user data of type Annotation |
| private IntervalTree annotations = |
| new IntervalTree(new Comparator() { |
| public int compare(Object o1, Object o2) { |
| Address a1 = (Address) o1; |
| Address a2 = (Address) o2; |
| |
| if ((a1 == null) && (a2 == null)) { |
| return 0; |
| } else if (a1 == null) { |
| return -1; |
| } else if (a2 == null) { |
| return 1; |
| } |
| |
| if (a1.equals(a2)) { |
| return 0; |
| } else if (a1.lessThan(a2)) { |
| return -1; |
| } |
| return 1; |
| } |
| }); |
| // Keep track of the last start address at which we painted, so we |
| // can scroll annotations |
| private Address lastStartAddr; |
| // This contains the list of currently-visible IntervalNodes, in |
| // sorted order by their low endpoint, in the form of a |
| // List<Annotation>. These annotations have already been laid out. |
| private java.util.List visibleAnnotations; |
| // Darker colors than defaults for better readability |
| private static Color[] colors = { |
| new Color(0.0f, 0.0f, 0.6f), // blue |
| new Color(0.6f, 0.0f, 0.6f), // magenta |
| new Color(0.0f, 0.8f, 0.0f), // green |
| new Color(0.8f, 0.3f, 0.0f), // orange |
| new Color(0.0f, 0.6f, 0.8f), // cyan |
| new Color(0.2f, 0.2f, 0.2f), // dark gray |
| }; |
| |
| /** Default is 32-bit mode */ |
| public AnnotatedMemoryPanel(Debugger debugger) { |
| this(debugger, false); |
| } |
| |
| public AnnotatedMemoryPanel(Debugger debugger, boolean is64Bit, Address addrValue, Address addrLow, Address addrHigh) { |
| super(); |
| init(debugger, is64Bit, addressToBigInt(addrValue), addressToBigInt(addrLow), addressToBigInt(addrHigh)); |
| } |
| |
| public AnnotatedMemoryPanel(Debugger debugger, boolean is64Bit ) { |
| super(); |
| init(debugger, is64Bit, defaultMemoryLocation(is64Bit), defaultMemoryLow(is64Bit), defaultMemoryHigh(is64Bit)); |
| } |
| |
| static class AnnoX { |
| int lineX; |
| Address highBound; |
| |
| public AnnoX(int lineX, Address highBound) { |
| this.lineX = lineX; |
| this.highBound = highBound; |
| } |
| } |
| |
| public synchronized void paintComponent(Graphics g) { |
| // System.err.println("AnnotatedMemoryPanel.paintComponent() " + ++paintCount); |
| super.paintComponent(g); |
| |
| // Clone the Graphics so we don't screw up its state for Swing |
| // drawing (as this code otherwise does) |
| g = g.create(); |
| |
| g.setFont(font); |
| g.setColor(Color.black); |
| Rectangle rect = new Rectangle(); |
| getBounds(rect); |
| String firstAddressString = null; |
| int lineHeight; |
| int addrWidth; |
| { |
| Rectangle2D bounds = GraphicsUtilities.getStringBounds(unmappedAddrString, g); |
| lineHeight = (int) bounds.getHeight(); |
| addrWidth = (int) bounds.getWidth(); |
| } |
| int addrX = (int) (0.25 * addrWidth); |
| int dataX = (int) (addrX + (1.5 * addrWidth)); |
| int lineStartX = dataX + addrWidth + 5; |
| int annoStartX = (int) (lineStartX + (0.75 * addrWidth)); |
| |
| int numLines = rect.height / lineHeight; |
| |
| BigInteger startVal = scrollBar.getValueHP(); |
| BigInteger perLine = new BigInteger(Integer.toString((int) addressSize)); |
| // lineCount and maxLines are both 1 less than expected |
| BigInteger lineCount = new BigInteger(Integer.toString((int) (numLines - 1))); |
| BigInteger maxLines = scrollBar.getMaximumHP().subtract(scrollBar.getMinimumHP()).divide(perLine); |
| if (lineCount.compareTo(maxLines) > 0) { |
| lineCount = maxLines; |
| } |
| BigInteger offsetVal = lineCount.multiply(perLine); |
| BigInteger endVal = startVal.add(offsetVal); |
| if (endVal.compareTo(scrollBar.getMaximumHP()) > 0) { |
| startVal = scrollBar.getMaximumHP().subtract(offsetVal); |
| endVal = scrollBar.getMaximumHP(); |
| // Sure seems like this call will cause us to immediately redraw... |
| scrollBar.setValueHP(startVal); |
| } |
| scrollBar.setVisibleAmountHP(offsetVal.add(perLine)); |
| scrollBar.setBlockIncrementHP(offsetVal); |
| |
| Address startAddr = bigIntToAddress(startVal); |
| Address endAddr = bigIntToAddress(endVal); |
| |
| // Scroll last-known annotations |
| int scrollOffset = 0; |
| if (lastStartAddr != null) { |
| scrollOffset = (int) lastStartAddr.minus(startAddr); |
| } else { |
| if (startAddr != null) { |
| scrollOffset = (int) (-1 * startAddr.minus(lastStartAddr)); |
| } |
| } |
| scrollOffset = scrollOffset * lineHeight / (int) addressSize; |
| scrollAnnotations(scrollOffset); |
| lastStartAddr = startAddr; |
| |
| int curY = lineHeight; |
| Address curAddr = startAddr; |
| for (int i = 0; i < numLines; i++) { |
| String s = bigIntToHexString(startVal); |
| g.drawString(s, addrX, curY); |
| try { |
| s = addressToString(startAddr.getAddressAt(i * addressSize)); |
| } |
| catch (UnmappedAddressException e) { |
| s = unmappedAddrString; |
| } |
| g.drawString(s, dataX, curY); |
| curY += lineHeight; |
| startVal = startVal.add(perLine); |
| } |
| |
| // Query for visible annotations (little slop to ensure we get the |
| // top and bottom) |
| // FIXME: it would be nice to have a more static layout; that is, |
| // if something scrolls off the bottom of the screen, other |
| // annotations still visible shouldn't change position |
| java.util.List va = |
| annotations.findAllNodesIntersecting(new Interval(startAddr.addOffsetTo(-addressSize), |
| endAddr.addOffsetTo(2 * addressSize))); |
| |
| // Render them |
| int curLineX = lineStartX; |
| int curTextX = annoStartX; |
| int curColorIdx = 0; |
| if (g instanceof Graphics2D) { |
| Stroke stroke = new BasicStroke(3.0f); |
| ((Graphics2D) g).setStroke(stroke); |
| } |
| |
| Stack drawStack = new Stack(); |
| |
| layoutAnnotations(va, g, curTextX, startAddr, lineHeight); |
| |
| for (Iterator iter = visibleAnnotations.iterator(); iter.hasNext(); ) { |
| Annotation anno = (Annotation) iter.next(); |
| Interval interval = anno.getInterval(); |
| |
| if (!drawStack.empty()) { |
| // See whether we can pop any items off the stack |
| boolean shouldContinue = true; |
| do { |
| AnnoX annoX = (AnnoX) drawStack.peek(); |
| if (annoX.highBound.lessThanOrEqual((Address) interval.getLowEndpoint())) { |
| curLineX = annoX.lineX; |
| drawStack.pop(); |
| shouldContinue = !drawStack.empty(); |
| } else { |
| shouldContinue = false; |
| } |
| } while (shouldContinue); |
| } |
| |
| // Draw a line covering the interval |
| Address lineStartAddr = (Address) interval.getLowEndpoint(); |
| // Give it a little slop |
| int lineStartY = (int) (lineStartAddr.minus(startAddr) * lineHeight / addressSize) + |
| (lineHeight / 3); |
| Address lineEndAddr = (Address) interval.getHighEndpoint(); |
| drawStack.push(new AnnoX(curLineX, lineEndAddr)); |
| int lineEndY = (int) (lineEndAddr.minus(startAddr) * lineHeight / addressSize); |
| g.setColor(anno.getColor()); |
| g.drawLine(curLineX, lineStartY, curLineX, lineEndY); |
| // Draw line to text |
| g.drawLine(curLineX, lineStartY, curTextX - 10, anno.getY() - (lineHeight / 2)); |
| curLineX += 8; |
| anno.draw(g); |
| ++curColorIdx; |
| } |
| } |
| |
| /** Add an annotation covering the address range [annotation.lowAddress, |
| annotation.highAddress); that is, it includes the low address and does not |
| include the high address. */ |
| public synchronized void addAnnotation(Annotation annotation) { |
| annotations.insert(annotation.getInterval(), annotation); |
| } |
| |
| /** Makes the given address visible somewhere in the window */ |
| public synchronized void makeVisible(Address addr) { |
| BigInteger bi = addressToBigInt(addr); |
| scrollBar.setValueHP(bi); |
| } |
| |
| public void print() { |
| printOn(System.out); |
| } |
| |
| public void printOn(PrintStream tty) { |
| annotations.printOn(tty); |
| } |
| |
| //---------------------------------------------------------------------- |
| // Internals only below this point |
| // |
| |
| private void init(Debugger debugger, boolean is64Bit, BigInteger addrValue, BigInteger addrLow, BigInteger addrHigh) { |
| this.is64Bit = is64Bit; |
| this.debugger = debugger; |
| if (is64Bit) { |
| addressSize = 8; |
| unmappedAddrString = "??????????????????"; |
| } else { |
| addressSize = 4; |
| unmappedAddrString = "??????????"; |
| } |
| setLayout(new BorderLayout()); |
| setupScrollBar(addrValue, addrLow, addrHigh); |
| add(scrollBar, BorderLayout.EAST); |
| visibleAnnotations = new ArrayList(); |
| setBackground(Color.white); |
| addHierarchyBoundsListener(new HierarchyBoundsListener() { |
| public void ancestorMoved(HierarchyEvent e) { |
| } |
| |
| public void ancestorResized(HierarchyEvent e) { |
| // FIXME: should perform incremental layout |
| // System.err.println("Ancestor resized"); |
| } |
| }); |
| |
| if (font == null) { |
| font = GraphicsUtilities.lookupFont("Courier"); |
| } |
| if (font == null) { |
| throw new RuntimeException("Error looking up monospace font Courier"); |
| } |
| getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, 0), "PageDown"); |
| getActionMap().put("PageDown", new AbstractAction() { |
| public void actionPerformed(ActionEvent e) { |
| scrollBar.setValueHP(scrollBar.getValueHP().add(scrollBar.getBlockIncrementHP())); |
| } |
| }); |
| getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, 0), "PageUp"); |
| getActionMap().put("PageUp", new AbstractAction() { |
| public void actionPerformed(ActionEvent e) { |
| scrollBar.setValueHP(scrollBar.getValueHP().subtract(scrollBar.getBlockIncrementHP())); |
| } |
| }); |
| getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), "Down"); |
| getActionMap().put("Down", new AbstractAction() { |
| public void actionPerformed(ActionEvent e) { |
| scrollBar.setValueHP(scrollBar.getValueHP().add(scrollBar.getUnitIncrementHP())); |
| } |
| }); |
| getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), "Up"); |
| getActionMap().put("Up", new AbstractAction() { |
| public void actionPerformed(ActionEvent e) { |
| scrollBar.setValueHP(scrollBar.getValueHP().subtract(scrollBar.getUnitIncrementHP())); |
| } |
| }); |
| setEnabled(true); |
| } |
| |
| private void setupScrollBar(BigInteger value, BigInteger min, BigInteger max) { |
| scrollBar = new HighPrecisionJScrollBar( Scrollbar.VERTICAL, value, min, max); |
| if (is64Bit) { |
| bytesPerLine = 8; |
| // 64-bit mode |
| scrollBar.setUnitIncrementHP(new BigInteger(1, new byte[] { |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x08})); |
| scrollBar.setBlockIncrementHP(new BigInteger(1, new byte[] { |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x40})); |
| } else { |
| // 32-bit mode |
| bytesPerLine = 4; |
| scrollBar.setUnitIncrementHP(new BigInteger(1, new byte[] { |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x04})); |
| scrollBar.setBlockIncrementHP(new BigInteger(1, new byte[] { |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x20})); |
| } |
| scrollBar.addChangeListener(new ChangeListener() { |
| public void stateChanged(ChangeEvent e) { |
| HighPrecisionJScrollBar h = (HighPrecisionJScrollBar) e.getSource(); |
| repaint(); |
| } |
| }); |
| } |
| |
| private static BigInteger defaultMemoryLocation(boolean is64Bit) { |
| if (is64Bit) { |
| return new BigInteger(1, new byte[] { |
| (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00}); |
| } else { |
| return new BigInteger(1, new byte[] { (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00}); |
| } |
| } |
| |
| private static BigInteger defaultMemoryLow(boolean is64Bit) { |
| if (is64Bit) { |
| return new BigInteger(1, new byte[] { |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, |
| (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00}); |
| } else { |
| return new BigInteger(1, new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00}); |
| } |
| } |
| |
| private static BigInteger defaultMemoryHigh(boolean is64Bit) { |
| if (is64Bit) { |
| return new BigInteger(1, new byte[] { |
| (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, |
| (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFC}); |
| } else { |
| return new BigInteger(1, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFC}); |
| } |
| } |
| |
| private void setupScrollBar() { |
| setupScrollBar(defaultMemoryLocation(is64Bit), |
| defaultMemoryLow(is64Bit), |
| defaultMemoryHigh(is64Bit)); |
| } |
| |
| private String bigIntToHexString(BigInteger bi) { |
| StringBuffer buf = new StringBuffer(); |
| buf.append("0x"); |
| String val = bi.toString(16); |
| for (int i = 0; i < ((2 * addressSize) - val.length()); i++) { |
| buf.append('0'); |
| } |
| buf.append(val); |
| return buf.toString(); |
| } |
| |
| private Address bigIntToAddress(BigInteger i) { |
| String s = bigIntToHexString(i); |
| return debugger.parseAddress(s); |
| } |
| |
| private BigInteger addressToBigInt(Address a) { |
| String s = addressToString(a); |
| if (!s.startsWith("0x")) { |
| throw new NumberFormatException(s); |
| } |
| return new BigInteger(s.substring(2), 16); |
| } |
| |
| private String addressToString(Address a) { |
| if (a == null) { |
| if (is64Bit) { |
| return "0x0000000000000000"; |
| } else { |
| return "0x00000000"; |
| } |
| } |
| return a.toString(); |
| } |
| |
| /** Scrolls the visible annotations by the given Y amount */ |
| private void scrollAnnotations(int y) { |
| for (Iterator iter = visibleAnnotations.iterator(); iter.hasNext(); ) { |
| Annotation anno = (Annotation) iter.next(); |
| anno.setY(anno.getY() + y); |
| } |
| } |
| |
| /** Takes the list of currently-visible annotations (in the form of |
| a List<IntervalNode>) and lays them out given the current |
| visible position and the already-visible annotations. Does not |
| perturb the layouts of the currently-visible annotations. */ |
| private void layoutAnnotations(java.util.List va, |
| Graphics g, |
| int x, |
| Address startAddr, |
| int lineHeight) { |
| // Handle degenerate case early: no visible annotations. |
| if (va.size() == 0) { |
| visibleAnnotations.clear(); |
| return; |
| } |
| |
| // We have two ranges of visible annotations: the one from the |
| // last repaint and the currently visible set. We want to preserve |
| // the layouts of the previously-visible annotations that are |
| // currently visible (to avoid color flashing, jumping, etc.) |
| // while making the coloring of the new annotations fit as well as |
| // possible. Note that annotations may appear and disappear from |
| // any point in the previously-visible list, but the ordering of |
| // the visible annotations is always the same. |
| |
| // This is really a constrained graph-coloring problem. This |
| // simple algorithm only takes into account half of the |
| // constraints (for example, the layout of the previous |
| // annotation, where it should be taking into account the layout |
| // of the previous and next annotations that were in the |
| // previously-visible list). There are situations where it can |
| // generate overlapping annotations and adjacent annotations with |
| // the same color; generally visible when scrolling line-by-line |
| // rather than page-by-page. In some of these situations, will |
| // have to move previously laid-out annotations. FIXME: revisit |
| // this. |
| |
| // Index of last annotation which we didn't know how to lay out |
| int deferredIndex = -1; |
| // We "lay out after" this one |
| Annotation constraintAnnotation = null; |
| // The first constraint annotation |
| Annotation firstConstraintAnnotation = null; |
| // The index from which we search forward in the |
| // visibleAnnotations list. This reduces the amount of work we do. |
| int searchIndex = 0; |
| // The new set of annotations |
| java.util.List newAnnos = new ArrayList(); |
| |
| for (Iterator iter = va.iterator(); iter.hasNext(); ) { |
| Annotation anno = (Annotation) ((IntervalNode) iter.next()).getData(); |
| |
| // Search forward for this one |
| boolean found = false; |
| for (int i = searchIndex; i < visibleAnnotations.size(); i++) { |
| Annotation el = (Annotation) visibleAnnotations.get(i); |
| // See whether we can abort the search unsuccessfully because |
| // we went forward too far |
| if (el.getLowAddress().greaterThan(anno.getLowAddress())) { |
| break; |
| } |
| if (el == anno) { |
| // Found successfully. |
| found = true; |
| searchIndex = i; |
| constraintAnnotation = anno; |
| if (firstConstraintAnnotation == null) { |
| firstConstraintAnnotation = constraintAnnotation; |
| } |
| break; |
| } |
| } |
| |
| if (!found) { |
| if (constraintAnnotation != null) { |
| layoutAfter(anno, constraintAnnotation, g, x, startAddr, lineHeight); |
| constraintAnnotation = anno; |
| } else { |
| // Defer layout of this annotation until later |
| ++deferredIndex; |
| } |
| } |
| |
| newAnnos.add(anno); |
| } |
| |
| if (firstConstraintAnnotation != null) { |
| // Go back and lay out deferred annotations |
| for (int i = deferredIndex; i >= 0; i--) { |
| Annotation anno = (Annotation) newAnnos.get(i); |
| layoutBefore(anno, firstConstraintAnnotation, g, x, startAddr, lineHeight); |
| firstConstraintAnnotation = anno; |
| } |
| } else { |
| // Didn't find any overlap between the old and new annotations. |
| // Lay out in a feed-forward fashion. |
| if (Assert.ASSERTS_ENABLED) { |
| Assert.that(constraintAnnotation == null, "logic error in layout code"); |
| } |
| for (Iterator iter = newAnnos.iterator(); iter.hasNext(); ) { |
| Annotation anno = (Annotation) iter.next(); |
| layoutAfter(anno, constraintAnnotation, g, x, startAddr, lineHeight); |
| constraintAnnotation = anno; |
| } |
| } |
| |
| visibleAnnotations = newAnnos; |
| } |
| |
| /** Lays out the given annotation before the optional constraint |
| annotation, obeying constraints imposed by that annotation if it |
| is specified. */ |
| private void layoutBefore(Annotation anno, Annotation constraintAnno, |
| Graphics g, int x, |
| Address startAddr, int lineHeight) { |
| anno.computeWidthAndHeight(g); |
| // Color |
| if (constraintAnno != null) { |
| anno.setColor(prevColor(constraintAnno.getColor())); |
| } else { |
| anno.setColor(colors[0]); |
| } |
| // X |
| anno.setX(x); |
| // Tentative Y |
| anno.setY((int) (((Address) anno.getInterval().getLowEndpoint()).minus(startAddr) * lineHeight / addressSize) + |
| (5 * lineHeight / 6)); |
| // See whether Y overlaps with last anno's Y; if so, move this one up |
| if ((constraintAnno != null) && (anno.getY() + anno.getHeight() > constraintAnno.getY())) { |
| anno.setY(constraintAnno.getY() - anno.getHeight()); |
| } |
| } |
| |
| /** Lays out the given annotation after the optional constraint |
| annotation, obeying constraints imposed by that annotation if it |
| is specified. */ |
| private void layoutAfter(Annotation anno, Annotation constraintAnno, |
| Graphics g, int x, |
| Address startAddr, int lineHeight) { |
| anno.computeWidthAndHeight(g); |
| // Color |
| if (constraintAnno != null) { |
| anno.setColor(nextColor(constraintAnno.getColor())); |
| } else { |
| anno.setColor(colors[0]); |
| } |
| // X |
| anno.setX(x); |
| // Tentative Y |
| anno.setY((int) (((Address) anno.getInterval().getLowEndpoint()).minus(startAddr) * lineHeight / addressSize) + |
| (5 * lineHeight / 6)); |
| // See whether Y overlaps with last anno's Y; if so, move this one down |
| if ((constraintAnno != null) && (anno.getY() < (constraintAnno.getY() + constraintAnno.getHeight()))) { |
| anno.setY(constraintAnno.getY() + constraintAnno.getHeight()); |
| } |
| } |
| |
| /** Returns previous color in our color palette */ |
| private Color prevColor(Color c) { |
| int i = findColorIndex(c); |
| if (i == 0) { |
| return colors[colors.length - 1]; |
| } else { |
| return colors[i - 1]; |
| } |
| } |
| |
| /** Returns next color in our color palette */ |
| private Color nextColor(Color c) { |
| return colors[(findColorIndex(c) + 1) % colors.length]; |
| } |
| |
| private int findColorIndex(Color c) { |
| for (int i = 0; i < colors.length; i++) { |
| if (colors[i] == c) { |
| return i; |
| } |
| } |
| throw new IllegalArgumentException(); |
| } |
| |
| public static void main(String[] args) { |
| JFrame frame = new JFrame(); |
| DummyDebugger debugger = new DummyDebugger(new MachineDescriptionIntelX86()); |
| AnnotatedMemoryPanel anno = new AnnotatedMemoryPanel(debugger); |
| frame.getContentPane().add(anno); |
| anno.addAnnotation(new Annotation(debugger.parseAddress("0x80000000"), |
| debugger.parseAddress("0x80000040"), |
| "Stack Frame for \"foo\"")); |
| anno.addAnnotation(new Annotation(debugger.parseAddress("0x80000010"), |
| debugger.parseAddress("0x80000020"), |
| "Locals for \"foo\"")); |
| anno.addAnnotation(new Annotation(debugger.parseAddress("0x80000020"), |
| debugger.parseAddress("0x80000030"), |
| "Expression stack for \"foo\"")); |
| |
| frame.setSize(400, 300); |
| frame.addWindowListener(new WindowAdapter() { |
| public void windowClosed(WindowEvent e) { |
| System.exit(0); |
| } |
| public void windowClosing(WindowEvent e) { |
| System.exit(0); |
| } |
| }); |
| frame.setVisible(true); |
| } |
| } |
