| /******************************************************************************* |
| * Copyright (c) 2005 The Regents of the University of California. |
| * This material was produced under U.S. Government contract W-7405-ENG-36 |
| * for Los Alamos National Laboratory, which is operated by the University |
| * of California for the U.S. Department of Energy. The U.S. Government has |
| * rights to use, reproduce, and distribute this software. NEITHER THE |
| * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR |
| * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified |
| * to produce derivative works, such modified software should be clearly marked, |
| * so as not to confuse it with the version available from LANL. |
| * |
| * Additionally, 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 |
| * |
| * LA-CC 04-115 |
| *******************************************************************************/ |
| package org.eclipse.ptp.internal.debug.ui; |
| |
| import java.math.BigInteger; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.debug.core.DebugException; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.model.IBreakpoint; |
| import org.eclipse.debug.core.model.IDebugTarget; |
| import org.eclipse.debug.core.model.IDisconnect; |
| import org.eclipse.debug.core.model.IExpression; |
| import org.eclipse.debug.core.model.IRegister; |
| import org.eclipse.debug.core.model.IRegisterGroup; |
| import org.eclipse.debug.core.model.IStackFrame; |
| import org.eclipse.debug.core.model.ITerminate; |
| import org.eclipse.debug.core.model.IThread; |
| import org.eclipse.debug.core.model.IValue; |
| import org.eclipse.debug.core.model.IVariable; |
| import org.eclipse.debug.core.model.IWatchExpression; |
| import org.eclipse.debug.ui.DebugUITools; |
| import org.eclipse.debug.ui.IDebugEditorPresentation; |
| import org.eclipse.debug.ui.IDebugModelPresentation; |
| import org.eclipse.debug.ui.IDebugUIConstants; |
| import org.eclipse.debug.ui.IValueDetailListener; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.ptp.debug.core.model.IEnableDisableTarget; |
| import org.eclipse.ptp.debug.core.model.IPAddressBreakpoint; |
| import org.eclipse.ptp.debug.core.model.IPBreakpoint; |
| import org.eclipse.ptp.debug.core.model.IPDebugElement; |
| import org.eclipse.ptp.debug.core.model.IPDebugElementStatus; |
| import org.eclipse.ptp.debug.core.model.IPDebugTarget; |
| import org.eclipse.ptp.debug.core.model.IPDummyStackFrame; |
| import org.eclipse.ptp.debug.core.model.IPFunctionBreakpoint; |
| import org.eclipse.ptp.debug.core.model.IPGlobalVariable; |
| import org.eclipse.ptp.debug.core.model.IPLineBreakpoint; |
| import org.eclipse.ptp.debug.core.model.IPModule; |
| import org.eclipse.ptp.debug.core.model.IPSignal; |
| import org.eclipse.ptp.debug.core.model.IPStackFrame; |
| import org.eclipse.ptp.debug.core.model.IPThread; |
| import org.eclipse.ptp.debug.core.model.IPValue; |
| import org.eclipse.ptp.debug.core.model.IPVariable; |
| import org.eclipse.ptp.debug.core.model.IPWatchpoint; |
| import org.eclipse.ptp.debug.core.model.PDebugElementState; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDIBreakpointInfo; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDIExitInfo; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDISharedLibraryInfo; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDISignalInfo; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDIWatchpointScopeInfo; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDIWatchpointTriggerInfo; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIF; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIFType; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIFTypeAggregate; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIFTypeArray; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIFTypeChar; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIFTypePointer; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIFTypeRange; |
| import org.eclipse.ptp.debug.core.pdi.model.aif.IAIFTypeReference; |
| import org.eclipse.ptp.internal.debug.core.sourcelookup.PSourceNotFoundElement; |
| import org.eclipse.ptp.internal.debug.ui.messages.Messages; |
| import org.eclipse.ptp.internal.ui.model.IElementHandler; |
| import org.eclipse.ptp.internal.ui.model.IElementSet; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| |
| /** |
| * @author Clement chu |
| * |
| */ |
| public class PDebugModelPresentation extends LabelProvider implements IDebugModelPresentation, IDebugEditorPresentation { |
| private static PDebugModelPresentation instance = null; |
| public final static String DISPLAY_FULL_PATHS = "DISPLAY_FULL_PATHS"; //$NON-NLS-1$ |
| private static final String DUMMY_STACKFRAME_LABEL = "..."; //$NON-NLS-1$ |
| |
| public static PDebugModelPresentation getDefault() { |
| if (instance == null) { |
| instance = new PDebugModelPresentation(); |
| } |
| return instance; |
| } |
| |
| protected Map<String, Object> attributes = new HashMap<String, Object>(3); |
| private final OverlayImageCache imageCache = new OverlayImageCache(); |
| |
| protected UIDebugManager uiDebugManager = null; |
| |
| /** |
| * Constructor |
| */ |
| public PDebugModelPresentation() { |
| // make sure using the one created by start up |
| if (instance == null) { |
| instance = this; |
| } |
| } |
| |
| public boolean addAnnotations(IEditorPart editorPart, IStackFrame frame) { |
| try { |
| if (frame instanceof IPStackFrame) { |
| PAnnotationManager.getDefault().addAnnotation(editorPart, (IPStackFrame) frame); |
| return true; |
| } |
| } catch (CoreException e) { |
| return false; |
| } |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.debug.ui.IDebugModelPresentation#computeDetail(org.eclipse |
| * .debug.core.model.IValue, org.eclipse.debug.ui.IValueDetailListener) |
| */ |
| public void computeDetail(IValue value, IValueDetailListener listener) { |
| PValueDetailProvider.getDefault().computeDetail(value, listener); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.BaseLabelProvider#dispose() |
| */ |
| @Override |
| public void dispose() { |
| getImageCache().disposeAll(); |
| attributes.clear(); |
| super.dispose(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.ui.ISourcePresentation#getEditorId(org.eclipse.ui. |
| * IEditorInput, java.lang.Object) |
| */ |
| public String getEditorId(IEditorInput input, Object element) { |
| return PDebugUIUtils.getEditorId(input, element); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.debug.ui.ISourcePresentation#getEditorInput(java.lang.Object) |
| */ |
| public IEditorInput getEditorInput(Object element) { |
| return PDebugUIUtils.getEditorInput(element); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object) |
| */ |
| @Override |
| public Image getImage(Object element) { |
| Image baseImage = getBaseImage(element); |
| if (baseImage != null) { |
| ImageDescriptor[] overlays = new ImageDescriptor[] { null, null, null, null }; |
| if (element instanceof IPDebugElementStatus && !((IPDebugElementStatus) element).isOK()) { |
| switch (((IPDebugElementStatus) element).getSeverity()) { |
| case IPDebugElementStatus.WARNING: |
| overlays[OverlayImageDescriptor.BOTTOM_LEFT] = PDebugImage.getDescriptor(PDebugImage.IMG_DEBUG_OVRS_WARNING); |
| break; |
| case IPDebugElementStatus.ERROR: |
| overlays[OverlayImageDescriptor.BOTTOM_LEFT] = PDebugImage.getDescriptor(PDebugImage.IMG_DEBUG_OVRS_ERROR); |
| break; |
| } |
| } |
| if (element instanceof IWatchExpression && ((IWatchExpression) element).hasErrors()) { |
| overlays[OverlayImageDescriptor.BOTTOM_LEFT] = PDebugImage.getDescriptor(PDebugImage.IMG_DEBUG_OVRS_ERROR); |
| } |
| if (element instanceof IPVariable && ((IPVariable) element).isArgument()) { |
| overlays[OverlayImageDescriptor.TOP_RIGHT] = PDebugImage.getDescriptor(PDebugImage.IMG_DEBUG_OVRS_ARGUMENT); |
| } |
| if (element instanceof IPGlobalVariable && !(element instanceof IRegister)) { |
| overlays[OverlayImageDescriptor.TOP_RIGHT] = PDebugImage.getDescriptor(PDebugImage.IMG_DEBUG_OVRS_GLOBAL); |
| } |
| |
| return getImageCache().getImageFor(new OverlayImageDescriptor(baseImage, overlays)); |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object) |
| */ |
| @Override |
| public String getText(Object element) { |
| String bt = getBaseText(element); |
| if (bt == null) { |
| return null; |
| } |
| StringBuffer baseText = new StringBuffer(bt); |
| if (element instanceof IPDebugElementStatus && !((IPDebugElementStatus) element).isOK()) { |
| baseText.append(NLS.bind(" <{0}>", new Object[] { ((IPDebugElementStatus) element).getMessage() })); //$NON-NLS-1$ |
| } |
| if (element instanceof IAdaptable) { |
| IEnableDisableTarget target = (IEnableDisableTarget) ((IAdaptable) element).getAdapter(IEnableDisableTarget.class); |
| if (target != null) { |
| if (!target.isEnabled()) { |
| baseText.append(' '); |
| baseText.append(Messages.PDebugModelPresentation_0); |
| } |
| } |
| } |
| return baseText.toString(); |
| } |
| |
| public void removeAnnotations(IEditorPart editorPart, IThread thread) { |
| // Empty |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.debug.ui.IDebugModelPresentation#setAttribute(java.lang.String |
| * , java.lang.Object) |
| */ |
| public void setAttribute(String attribute, Object value) { |
| if (value == null) { |
| return; |
| } |
| getAttributes().put(attribute, value); |
| } |
| |
| private ImageDescriptor[] computeBreakpointOverlays(IPBreakpoint breakpoint) { |
| ImageDescriptor[] overlays = new ImageDescriptor[] { null, null, null, null }; |
| try { |
| if (breakpoint.isGlobal()) { |
| overlays[OverlayImageDescriptor.TOP_LEFT] = (breakpoint.isEnabled()) ? PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_GLOB_EN) : PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_GLOB_DI); |
| } |
| if (breakpoint.isConditional()) { |
| overlays[OverlayImageDescriptor.BOTTOM_LEFT] = (breakpoint.isEnabled()) ? PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_COND_EN) : PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_COND_DI); |
| } |
| if (breakpoint.isInstalled()) { |
| overlays[OverlayImageDescriptor.BOTTOM_LEFT] = (breakpoint.isEnabled()) ? PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_INST_EN) : PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_INST_DI); |
| } |
| if (breakpoint instanceof IPAddressBreakpoint) { |
| overlays[OverlayImageDescriptor.TOP_RIGHT] = (breakpoint.isEnabled()) ? PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_ADDR_EN) : PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_ADDR_DI); |
| } |
| if (breakpoint instanceof IPFunctionBreakpoint) { |
| overlays[OverlayImageDescriptor.BOTTOM_RIGHT] = (breakpoint.isEnabled()) ? PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_FUNC_EN) : PDebugImage |
| .getDescriptor(PDebugImage.IMG_DEBUG_OVER_BPT_FUNC_DI); |
| } |
| } catch (CoreException e) { |
| PTPDebugUIPlugin.log(e); |
| } |
| return overlays; |
| } |
| |
| private Map<String, Object> getAttributes() { |
| return attributes; |
| } |
| |
| /** |
| * Get base image |
| * |
| * @param element |
| * @return |
| */ |
| private Image getBaseImage(Object element) { |
| if (element instanceof IPDebugTarget) { |
| IPDebugTarget target = (IPDebugTarget) element; |
| if (target.isPostMortem()) { |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_DEBUG_TARGET_TERMINATED); |
| } |
| if (target.isTerminated() || target.isDisconnected()) { |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_DEBUG_TARGET_TERMINATED); |
| } |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_DEBUG_TARGET); |
| } |
| if (element instanceof IPThread) { |
| IPThread thread = (IPThread) element; |
| IPDebugTarget target = thread.getDebugTarget(); |
| if (target.isPostMortem()) { |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_THREAD_TERMINATED); |
| } |
| if (thread.isSuspended()) { |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_THREAD_SUSPENDED); |
| } else if (thread.isTerminated()) { |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_THREAD_TERMINATED); |
| } else { |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_THREAD_RUNNING); |
| } |
| } |
| if (element instanceof IMarker) { |
| IBreakpoint bp = getBreakpoint((IMarker) element); |
| if (bp != null && bp instanceof IPBreakpoint) { |
| return getBreakpointImage((IPBreakpoint) bp); |
| } |
| } |
| if (element instanceof IPBreakpoint) { |
| return getBreakpointImage((IPBreakpoint) element); |
| } |
| if (element instanceof IRegisterGroup) { |
| return getRegisterGroupImage((IRegisterGroup) element); |
| } |
| if (element instanceof IExpression) { |
| return getExpressionImage((IExpression) element); |
| } |
| if (element instanceof IRegister) { |
| return getRegisterImage((IRegister) element); |
| } |
| if (element instanceof IVariable) { |
| return getVariableImage((IVariable) element); |
| } |
| if (element instanceof IPModule) { |
| return getModuleImage((IPModule) element); |
| } |
| if (element instanceof IPSignal) { |
| return getSignalImage((IPSignal) element); |
| } |
| return super.getImage(element); |
| } |
| |
| private String getBaseText(Object element) { |
| boolean showQualified = isShowQualifiedNames(); |
| StringBuffer label = new StringBuffer(); |
| try { |
| if (element instanceof IPModule) { |
| label.append(getModuleText((IPModule) element, showQualified)); |
| return label.toString(); |
| } |
| if (element instanceof IPSignal) { |
| label.append(getSignalText((IPSignal) element)); |
| return label.toString(); |
| } |
| if (element instanceof IRegisterGroup) { |
| label.append(((IRegisterGroup) element).getName()); |
| return label.toString(); |
| } |
| if (element instanceof IWatchExpression) { |
| return getWatchExpressionText((IWatchExpression) element); |
| } |
| if (element instanceof IVariable) { |
| label.append(getVariableText((IVariable) element)); |
| return label.toString(); |
| } |
| if (element instanceof IValue) { |
| label.append(getValueText((IValue) element)); |
| return label.toString(); |
| } |
| if (element instanceof IStackFrame) { |
| label.append(getStackFrameText((IStackFrame) element, showQualified)); |
| return label.toString(); |
| } |
| if (element instanceof PSourceNotFoundElement) { |
| return getBaseText(((PSourceNotFoundElement) element).getElement()); |
| } |
| if (element instanceof IMarker) { |
| IBreakpoint breakpoint = getBreakpoint((IMarker) element); |
| if (breakpoint != null) { |
| return getBreakpointText(breakpoint, showQualified); |
| } |
| return null; |
| } |
| if (element instanceof IBreakpoint) { |
| return getBreakpointText((IBreakpoint) element, showQualified); |
| } |
| if (element instanceof IDebugTarget) { |
| label.append(getTargetText((IDebugTarget) element, showQualified)); |
| } else if (element instanceof IThread) { |
| label.append(getThreadText((IThread) element, showQualified)); |
| } |
| if (label.length() > 0) { |
| return label.toString(); |
| } |
| if (element instanceof ITerminate) { |
| if (((ITerminate) element).isTerminated()) { |
| label.insert(0, Messages.PDebugModelPresentation_1); |
| return label.toString(); |
| } |
| } |
| if (element instanceof IDisconnect) { |
| if (((IDisconnect) element).isDisconnected()) { |
| label.insert(0, Messages.PDebugModelPresentation_2); |
| return label.toString(); |
| } |
| } |
| if (label.length() > 0) { |
| return label.toString(); |
| } |
| } catch (DebugException e) { |
| return NLS.bind(Messages.PDebugModelPresentation_3, new Object[] { e.getMessage() }); |
| } catch (CoreException e) { |
| PTPDebugUIPlugin.log(e); |
| } |
| return null; |
| } |
| |
| private String getDummyStackFrameLabel(IStackFrame stackFrame) { |
| return DUMMY_STACKFRAME_LABEL; |
| } |
| |
| private OverlayImageCache getImageCache() { |
| return imageCache; |
| } |
| |
| /** |
| * Get UIDebugManager |
| * |
| * @return |
| */ |
| private UIDebugManager getUIDebugManager() { |
| if (uiDebugManager == null) { |
| uiDebugManager = PTPDebugUIPlugin.getUIDebugManager(); |
| } |
| return uiDebugManager; |
| } |
| |
| private String getVariableTypeName(IAIF aif) { |
| StringBuffer result = new StringBuffer(); |
| if (aif != null) { |
| IAIFType type = aif.getType(); |
| if (type != null) { |
| result.append(type.toString().trim()); |
| while (type instanceof IAIFTypeArray) { |
| IAIFTypeRange range = ((IAIFTypeArray) type).getRange(); |
| result.append('['); |
| result.append(range.getSize()); |
| result.append(']'); |
| type = ((IAIFTypeArray) type).getBaseType(); |
| } |
| } |
| } |
| return result.toString(); |
| } |
| |
| private boolean isEmpty(String string) { |
| return (string == null || string.trim().length() == 0); |
| } |
| |
| protected StringBuffer appendBreakpointStatus(IPBreakpoint breakpoint, StringBuffer label) throws CoreException { |
| label.append(" "); //$NON-NLS-1$ |
| label.append("{"); //$NON-NLS-1$ |
| label.append(breakpoint.getJobName()); |
| label.append(":"); //$NON-NLS-1$ |
| label.append(breakpoint.getSetId()); |
| label.append("}"); //$NON-NLS-1$ |
| return label; |
| } |
| |
| protected StringBuffer appendLineNumber(IPLineBreakpoint breakpoint, StringBuffer label) throws CoreException { |
| int lineNumber = breakpoint.getLineNumber(); |
| if (lineNumber > 0) { |
| label.append(" "); //$NON-NLS-1$ |
| label.append(NLS.bind(Messages.PDebugModelPresentation_4, new Object[] { Integer.toString(lineNumber) })); |
| } |
| return label; |
| } |
| |
| protected StringBuffer appendSourceName(IPBreakpoint breakpoint, StringBuffer label, boolean qualified) throws CoreException { |
| String handle = breakpoint.getSourceHandle(); |
| if (!isEmpty(handle)) { |
| IPath path = new Path(handle); |
| if (path.isValidPath(handle)) { |
| label.append(qualified ? path.toOSString() : path.lastSegment()); |
| } |
| } |
| return label; |
| } |
| |
| protected IBreakpoint getBreakpoint(IMarker marker) { |
| return DebugPlugin.getDefault().getBreakpointManager().getBreakpoint(marker); |
| } |
| |
| protected Image getBreakpointImage(IPBreakpoint breakpoint) { |
| try { |
| if (breakpoint instanceof IPLineBreakpoint) { |
| return getLineBreakpointImage((IPLineBreakpoint) breakpoint); |
| } |
| if (breakpoint instanceof IPWatchpoint) { |
| return getWatchpointImage((IPWatchpoint) breakpoint); |
| } |
| } catch (CoreException e) { |
| PTPDebugUIPlugin.log(e); |
| } |
| return null; |
| } |
| |
| protected String getBreakpointText(IBreakpoint breakpoint, boolean qualified) throws CoreException { |
| if (breakpoint instanceof IPLineBreakpoint) { |
| return getLineBreakpointText((IPLineBreakpoint) breakpoint, qualified); |
| } |
| return ""; //$NON-NLS-1$ |
| } |
| |
| protected Image getExpressionImage(IExpression element) { |
| return DebugUITools.getImage(IDebugUIConstants.IMG_OBJS_EXPRESSION); |
| } |
| |
| protected Image getLineBreakpointImage(IPLineBreakpoint breakpoint) throws CoreException { |
| String job_id = breakpoint.getJobId(); |
| String cur_job_id = getUIDebugManager().getCurrentJobId(); |
| // Display nothing if the breakpoint is not in current job |
| if (!job_id.equals(IPBreakpoint.GLOBAL) && !job_id.equals(cur_job_id)) { |
| return new Image(null, 1, 1); |
| } |
| String descriptor = null; |
| IElementHandler setManager = getUIDebugManager().getElementHandler(job_id); |
| if (setManager == null) { |
| descriptor = breakpoint.isEnabled() ? PDebugImage.IMG_DEBUG_BPTCURSET_EN : PDebugImage.IMG_DEBUG_BPTCURSET_DI; |
| } else { // created job |
| String cur_set_id = getUIDebugManager().getCurrentSetId(); |
| String bpt_set_id = breakpoint.getSetId(); |
| if (bpt_set_id.equals(cur_set_id)) { |
| descriptor = breakpoint.isEnabled() ? PDebugImage.IMG_DEBUG_BPTCURSET_EN : PDebugImage.IMG_DEBUG_BPTCURSET_DI; |
| } else { |
| IElementSet set = setManager.getSet(bpt_set_id); |
| if (set == null) { |
| descriptor = breakpoint.isEnabled() ? PDebugImage.IMG_DEBUG_BPTCURSET_EN : PDebugImage.IMG_DEBUG_BPTCURSET_DI; |
| } else { |
| if (set.containsMatchSet(cur_set_id)) { |
| descriptor = breakpoint.isEnabled() ? PDebugImage.IMG_DEBUG_BPTMULTISET_EN |
| : PDebugImage.IMG_DEBUG_BPTMULTISET_DI; |
| } else { |
| descriptor = breakpoint.isEnabled() ? PDebugImage.IMG_DEBUG_BPTNOSET_EN : PDebugImage.IMG_DEBUG_BPTNOSET_DI; |
| } |
| } |
| } |
| } |
| return getImageCache().getImageFor( |
| new OverlayImageDescriptor(PDebugImage.getImage(descriptor), computeBreakpointOverlays(breakpoint))); |
| } |
| |
| protected String getLineBreakpointText(IPLineBreakpoint breakpoint, boolean qualified) throws CoreException { |
| StringBuffer label = new StringBuffer(); |
| appendSourceName(breakpoint, label, qualified); |
| appendLineNumber(breakpoint, label); |
| appendBreakpointStatus(breakpoint, label); |
| return label.toString(); |
| } |
| |
| protected Image getModuleImage(IPModule element) { |
| switch (element.getType()) { |
| case IPModule.EXECUTABLE: |
| if (element.areSymbolsLoaded()) { |
| return PDebugImage.getImage(PDebugImage.IMG_DEBUG_EXECUTABLE_WITH_SYMBOLS); |
| } |
| return PDebugImage.getImage(PDebugImage.IMG_DEBUG_EXECUTABLE); |
| case IPModule.SHARED_LIBRARY: |
| if (element.areSymbolsLoaded()) { |
| return PDebugImage.getImage(PDebugImage.IMG_DEBUG_SHARED_LIBRARY_WITH_SYMBOLS); |
| } |
| return PDebugImage.getImage(PDebugImage.IMG_DEBUG_SHARED_LIBRARY); |
| } |
| return null; |
| } |
| |
| protected String getModuleText(IPModule module, boolean qualified) { |
| StringBuffer sb = new StringBuffer(); |
| IPath path = module.getImageName(); |
| if (!path.isEmpty()) { |
| sb.append(path.lastSegment()); |
| } else { |
| sb.append(Messages.PDebugModelPresentation_5); |
| } |
| return sb.toString(); |
| } |
| |
| protected Image getRegisterGroupImage(IRegisterGroup element) { |
| IEnableDisableTarget target = (IEnableDisableTarget) element.getAdapter(IEnableDisableTarget.class); |
| if (target != null && !target.isEnabled()) { |
| return PDebugImage.getImage(PDebugImage.IMG_DEBUG_REGISTER_GROUP_DISABLED); |
| } |
| return PDebugImage.getImage(PDebugImage.IMG_DEBUG_REGISTER_GROUP); |
| } |
| |
| protected String getRegisterGroupText(IRegisterGroup group) { |
| String name = Messages.PDebugModelPresentation_6; |
| try { |
| name = group.getName(); |
| } catch (DebugException e) { |
| PTPDebugUIPlugin.log(e.getStatus()); |
| } |
| return name; |
| } |
| |
| protected Image getRegisterImage(IRegister element) { |
| return ((element instanceof IPVariable && ((IPVariable) element).isEnabled())) ? PDebugImage |
| .getImage(PDebugImage.IMG_DEBUG_REGISTER) : PDebugImage.getImage(PDebugImage.IMG_DEBUG_REGISTER_DISABLED); |
| } |
| |
| protected Image getSignalImage(IPSignal signal) { |
| return PDebugImage.getImage(PDebugImage.IMG_DEBUG_SIGNAL); |
| } |
| |
| protected String getSignalText(IPSignal signal) { |
| StringBuffer sb = new StringBuffer(Messages.PDebugModelPresentation_7); |
| try { |
| String name = signal.getName(); |
| sb.append(" \'").append(name).append('\''); //$NON-NLS-1$ |
| } catch (DebugException e) { |
| } |
| return sb.toString(); |
| } |
| |
| protected String getStackFrameText(IStackFrame f, boolean qualified) throws DebugException { |
| if (f instanceof IPStackFrame) { |
| IPStackFrame frame = (IPStackFrame) f; |
| StringBuffer label = new StringBuffer(); |
| label.append(frame.getLevel()); |
| label.append(' '); |
| String function = frame.getFunction(); |
| if (isEmpty(function)) { |
| label.append(Messages.PDebugModelPresentation_8); |
| } else { |
| function = function.trim(); |
| if (function.length() > 0) { |
| label.append(function); |
| if (!function.contains("(")) { //$NON-NLS-1$ |
| label.append("()"); //$NON-NLS-1$ |
| } |
| label.append(" "); //$NON-NLS-1$ |
| if (frame.getFile() != null) { |
| IPath path = new Path(frame.getFile()); |
| if (!path.isEmpty()) { |
| label.append((qualified ? path.toOSString() : path.lastSegment())); |
| label.append(':'); |
| if (frame.getFrameLineNumber() != 0) { |
| label.append(frame.getFrameLineNumber()); |
| } |
| } |
| } |
| } |
| } |
| BigInteger address = frame.getAddress(); |
| if (address != null) { |
| label.append(' '); |
| label.append(address.toString(16)); |
| } |
| return label.toString(); |
| } |
| return (f.getAdapter(IPDummyStackFrame.class) != null) ? getDummyStackFrameLabel(f) : f.getName(); |
| } |
| |
| protected String getTargetText(IDebugTarget target, boolean qualified) throws DebugException { |
| IPDebugTarget t = (IPDebugTarget) target.getAdapter(IPDebugTarget.class); |
| if (t != null) { |
| if (!t.isPostMortem()) { |
| PDebugElementState state = t.getState(); |
| if (state.equals(PDebugElementState.EXITED)) { |
| Object info = t.getCurrentStateInfo(); |
| String label = Messages.PDebugModelPresentation_9; |
| String reason = ""; //$NON-NLS-1$ |
| if (info != null && info instanceof IPDISignalInfo) { |
| IPDISignalInfo sigInfo = (IPDISignalInfo) info; |
| reason = ' ' + NLS.bind(Messages.PDebugModelPresentation_10, |
| new Object[] { sigInfo.getName(), sigInfo.getDescription() }); |
| } else if (info != null && info instanceof IPDIExitInfo) { |
| reason = ' ' + NLS.bind(Messages.PDebugModelPresentation_11, new Object[] { new Integer( |
| ((IPDIExitInfo) info).getCode()) }); |
| } |
| return NLS.bind(label, new Object[] { target.getName(), reason }); |
| } else if (state.equals(PDebugElementState.SUSPENDED)) { |
| return NLS.bind(Messages.PDebugModelPresentation_12, new Object[] { target.getName() }); |
| } |
| } |
| } |
| return target.getName(); |
| } |
| |
| protected String getThreadText(IThread thread, boolean qualified) throws DebugException { |
| IPDebugTarget target = (IPDebugTarget) thread.getDebugTarget().getAdapter(IPDebugTarget.class); |
| if (target.isPostMortem()) { |
| return NLS.bind(Messages.PDebugModelPresentation_13, new Object[] { thread.getName() }); |
| } |
| if (thread.isTerminated()) { |
| return NLS.bind(Messages.PDebugModelPresentation_14, new Object[] { thread.getName() }); |
| } |
| if (thread.isStepping()) { |
| return NLS.bind(Messages.PDebugModelPresentation_15, new Object[] { thread.getName() }); |
| } |
| if (!thread.isSuspended()) { |
| return NLS.bind(Messages.PDebugModelPresentation_16, new Object[] { thread.getName() }); |
| } |
| if (thread.isSuspended()) { |
| String reason = ""; //$NON-NLS-1$ |
| IPDebugElement element = (IPDebugElement) thread.getAdapter(IPDebugElement.class); |
| if (element != null) { |
| Object info = element.getCurrentStateInfo(); |
| if (info != null && info instanceof IPDISignalInfo) { |
| reason = NLS.bind(Messages.PDebugModelPresentation_23, new Object[] { ((IPDISignalInfo) info).getName(), |
| ((IPDISignalInfo) info).getDescription() }); |
| } else if (info != null && info instanceof IPDIWatchpointTriggerInfo) { |
| reason = NLS.bind( |
| Messages.PDebugModelPresentation_17, |
| new Object[] { ((IPDIWatchpointTriggerInfo) info).getOldValue(), |
| ((IPDIWatchpointTriggerInfo) info).getNewValue() }); |
| } else if (info != null && info instanceof IPDIWatchpointScopeInfo) { |
| reason = Messages.PDebugModelPresentation_18; |
| } else if (info != null && info instanceof IPDIBreakpointInfo) { |
| reason = Messages.PDebugModelPresentation_19; |
| } else if (info != null && info instanceof IPDISharedLibraryInfo) { |
| reason = Messages.PDebugModelPresentation_20; |
| } |
| } |
| return NLS.bind(Messages.PDebugModelPresentation_21, new Object[] { thread.getName(), reason }); |
| } |
| return NLS.bind(Messages.PDebugModelPresentation_13, new Object[] { thread.getName() }); |
| } |
| |
| protected String getValueText(IValue value) { |
| StringBuffer label = new StringBuffer(); |
| if (value instanceof IPDebugElementStatus && !((IPDebugElementStatus) value).isOK()) { |
| label.append(NLS.bind(Messages.PDebugModelPresentation_22, new Object[] { ((IPDebugElementStatus) value).getMessage() })); |
| } else if (value instanceof IPValue) { |
| IAIF aif = null; |
| try { |
| aif = ((IPValue) value).getAIF(); |
| } catch (DebugException e) { |
| // don't display type |
| } |
| try { |
| String valueString = value.getValueString(); |
| if (valueString != null) { |
| valueString = valueString.trim(); |
| if (aif != null && aif instanceof IAIFTypeChar) { |
| if (valueString.length() == 0) { |
| valueString = "."; //$NON-NLS-1$ |
| } |
| label.append(valueString); |
| } else if (aif == null |
| || (!(aif.getType() instanceof IAIFTypeArray) && !(aif.getType() instanceof IAIFTypeAggregate))) { |
| if (valueString.length() > 0) { |
| label.append(valueString); |
| } |
| } |
| } |
| } catch (DebugException e1) { |
| } |
| } |
| return label.toString(); |
| } |
| |
| protected Image getVariableImage(IVariable element) { |
| if (element instanceof IPVariable) { |
| IAIF aif = null; |
| try { |
| aif = ((IPVariable) element).getAIF(); |
| } catch (DebugException e) { |
| // use default image |
| } |
| if (aif == null) { |
| return PDebugImage.getImage((((IPVariable) element).isEnabled()) ? PDebugImage.IMG_DEBUG_VARIABLE_SIMPLE |
| : PDebugImage.IMG_DEBUG_VARIABLE_SIMPLE_DISABLED); |
| } |
| IAIFType type = aif.getType(); |
| if (type instanceof IAIFTypePointer || type instanceof IAIFTypeReference) { |
| return PDebugImage.getImage((((IPVariable) element).isEnabled()) ? PDebugImage.IMG_DEBUG_VARIABLE_POINTER |
| : PDebugImage.IMG_DEBUG_VARIABLE_POINTER_DISABLED); |
| } else if (type instanceof IAIFTypeArray || type instanceof IAIFTypeAggregate) { |
| return PDebugImage.getImage((((IPVariable) element).isEnabled()) ? PDebugImage.IMG_DEBUG_VARIABLE_AGGREGATE |
| : PDebugImage.IMG_DEBUG_VARIABLE_AGGREGATE_DISABLED); |
| } else { |
| return PDebugImage.getImage((((IPVariable) element).isEnabled()) ? PDebugImage.IMG_DEBUG_VARIABLE_SIMPLE |
| : PDebugImage.IMG_DEBUG_VARIABLE_SIMPLE_DISABLED); |
| } |
| } |
| return null; |
| } |
| |
| protected String getVariableText(IVariable var) throws DebugException { |
| StringBuffer label = new StringBuffer(); |
| if (var instanceof IPVariable) { |
| IAIF aif = null; |
| try { |
| aif = ((IPVariable) var).getAIF(); |
| } catch (DebugException e) { |
| // don't display type |
| } |
| if (aif != null && isShowVariableTypeNames()) { |
| String typeName = getVariableTypeName(aif); |
| if (typeName != null && typeName.length() > 0) { |
| label.append(typeName).append(' '); |
| } |
| } |
| String name = var.getName(); |
| if (name != null) { |
| label.append(name.trim()); |
| } |
| String valueString = getValueText(var.getValue()); |
| if (!isEmpty(valueString)) { |
| label.append(" = "); //$NON-NLS-1$ |
| label.append(valueString); |
| } |
| } |
| return label.toString(); |
| } |
| |
| protected String getWatchExpressionText(IWatchExpression expression) { |
| StringBuffer result = new StringBuffer(); |
| result.append('"').append(expression.getExpressionText()).append('"'); |
| if (expression.isPending()) { |
| result.append(" = ").append("..."); //$NON-NLS-1$ //$NON-NLS-2$ |
| } else { |
| IValue value = expression.getValue(); |
| if (value instanceof IPValue) { |
| IAIF aif = null; |
| try { |
| aif = ((IPValue) value).getAIF(); |
| } catch (DebugException e1) { |
| } |
| if (aif != null && isShowVariableTypeNames()) { |
| String typeName = getVariableTypeName(aif); |
| if (!isEmpty(typeName)) { |
| result.insert(0, typeName + ' '); |
| } |
| } |
| if (expression.isEnabled()) { |
| String valueString = getValueText(value); |
| if (valueString.length() > 0) { |
| result.append(" = ").append(valueString); //$NON-NLS-1$ |
| } |
| } |
| } |
| } |
| if (!expression.isEnabled()) { |
| result.append(' '); |
| result.append(Messages.PDebugModelPresentation_0); |
| } |
| return result.toString(); |
| } |
| |
| protected Image getWatchpointImage(IPWatchpoint watchpoint) throws CoreException { |
| String descriptor = null; |
| if (watchpoint.isEnabled()) { |
| if (watchpoint.isReadType() && !watchpoint.isWriteType()) { |
| descriptor = PDebugImage.IMG_DEBUG_READ_WATCHPOINT_ENABLED; |
| } else if (!watchpoint.isReadType() && watchpoint.isWriteType()) { |
| descriptor = PDebugImage.IMG_DEBUG_WRITE_WATCHPOINT_ENABLED; |
| } else { |
| descriptor = PDebugImage.IMG_DEBUG_WATCHPOINT_ENABLED; |
| } |
| } else { |
| if (watchpoint.isReadType() && !watchpoint.isWriteType()) { |
| descriptor = PDebugImage.IMG_DEBUG_READ_WATCHPOINT_DISABLED; |
| } else if (!watchpoint.isReadType() && watchpoint.isWriteType()) { |
| descriptor = PDebugImage.IMG_DEBUG_WRITE_WATCHPOINT_DISABLED; |
| } else { |
| descriptor = PDebugImage.IMG_DEBUG_WATCHPOINT_DISABLED; |
| } |
| } |
| return getImageCache().getImageFor( |
| new OverlayImageDescriptor(PDebugImage.getImage(descriptor), computeBreakpointOverlays(watchpoint))); |
| } |
| |
| protected boolean isShowQualifiedNames() { |
| Boolean showQualified = (Boolean) getAttributes().get(DISPLAY_FULL_PATHS); |
| showQualified = (showQualified == null) ? Boolean.FALSE : showQualified; |
| return showQualified.booleanValue(); |
| } |
| |
| protected boolean isShowVariableTypeNames() { |
| Boolean show = (Boolean) getAttributes().get(DISPLAY_VARIABLE_TYPE_NAMES); |
| show = show == null ? Boolean.FALSE : show; |
| return show.booleanValue(); |
| } |
| } |
