| /******************************************************************************* |
| * 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.debug.internal.core.model; |
| |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.debug.core.DebugException; |
| import org.eclipse.debug.core.model.IMemoryBlockRetrieval; |
| import org.eclipse.debug.core.model.IRegisterGroup; |
| import org.eclipse.debug.core.model.ISourceLocator; |
| import org.eclipse.debug.core.model.IStackFrame; |
| import org.eclipse.debug.core.model.IThread; |
| import org.eclipse.debug.core.model.IValue; |
| import org.eclipse.debug.core.model.IVariable; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.ptp.debug.core.messages.Messages; |
| import org.eclipse.ptp.debug.core.model.IJumpToAddress; |
| import org.eclipse.ptp.debug.core.model.IJumpToLine; |
| import org.eclipse.ptp.debug.core.model.IPGlobalVariable; |
| import org.eclipse.ptp.debug.core.model.IPStackFrame; |
| import org.eclipse.ptp.debug.core.model.IPVariable; |
| import org.eclipse.ptp.debug.core.model.IRestart; |
| import org.eclipse.ptp.debug.core.model.IResumeWithoutSignal; |
| import org.eclipse.ptp.debug.core.model.IRunToAddress; |
| import org.eclipse.ptp.debug.core.model.IRunToLine; |
| import org.eclipse.ptp.debug.core.pdi.IPDILocation; |
| import org.eclipse.ptp.debug.core.pdi.IPDILocator; |
| import org.eclipse.ptp.debug.core.pdi.PDIException; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDIEvent; |
| import org.eclipse.ptp.debug.core.pdi.event.IPDIEventListener; |
| import org.eclipse.ptp.debug.core.pdi.model.IPDIStackFrame; |
| import org.eclipse.ptp.debug.core.pdi.model.IPDITargetExpression; |
| import org.eclipse.ptp.debug.core.pdi.model.IPDIThread; |
| import org.eclipse.ptp.debug.core.pdi.model.IPDIVariableDescriptor; |
| import org.eclipse.ptp.debug.core.sourcelookup.IPSourceLocator; |
| |
| import com.ibm.icu.text.NumberFormat; |
| |
| /** |
| * @author Clement chu |
| * |
| */ |
| public class PStackFrame extends PDebugElement implements IPStackFrame, IRestart, IResumeWithoutSignal, IPDIEventListener { |
| /** |
| * @param frameOne |
| * @param frameTwo |
| * @return |
| */ |
| protected static boolean equalFrame(IPDIStackFrame frameOne, IPDIStackFrame frameTwo) { |
| if (frameOne == null || frameTwo == null) |
| return false; |
| IPDILocator loc1 = frameOne.getLocator(); |
| IPDILocator loc2 = frameTwo.getLocator(); |
| if (loc1 == null || loc2 == null) |
| return false; |
| if (loc1.getFile() != null && loc1.getFile().length() > 0 && loc2.getFile() != null && loc2.getFile().length() > 0 |
| && loc1.getFile().equals(loc2.getFile())) { |
| if (loc1.getFunction() != null && loc1.getFunction().length() > 0 && loc2.getFunction() != null |
| && loc2.getFunction().length() > 0 && loc1.getFunction().equals(loc2.getFunction())) |
| return true; |
| } |
| if ((loc1.getFile() == null || loc1.getFile().length() < 1) && (loc2.getFile() == null || loc2.getFile().length() < 1)) { |
| if (loc1.getFunction() != null && loc1.getFunction().length() > 0 && loc2.getFunction() != null |
| && loc2.getFunction().length() > 0 && loc1.getFunction().equals(loc2.getFunction())) |
| return true; |
| } |
| if ((loc1.getFile() == null || loc1.getFile().length() < 1) && (loc2.getFile() == null || loc2.getFile().length() < 1) |
| && (loc1.getFunction() == null || loc1.getFunction().length() < 1) |
| && (loc2.getFunction() == null || loc2.getFunction().length() < 1)) { |
| if (loc1.getAddress() == loc2.getAddress()) |
| return true; |
| } |
| return false; |
| } |
| |
| private IPDIStackFrame pdiStackFrame; |
| private IPDIStackFrame lastPDIStackFrame; |
| private PThread fThread; |
| private List<IPVariable> fVariables; |
| private boolean fRefreshVariables = true; |
| private List<PExpression> fExpressions; |
| |
| private boolean fIsDisposed = false; |
| |
| public PStackFrame(PThread thread, IPDIStackFrame pdiFrame) { |
| super(thread.getSession(), thread.getTasks()); |
| setPDIStackFrame(pdiFrame); |
| setThread(thread); |
| getPDISession().getEventManager().addEventListener(this); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#canEvaluate() |
| */ |
| public boolean canEvaluate() { |
| return getDebugTarget().isSuspended(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IJumpToAddress#canJumpToAddress(java |
| * .math.BigInteger) |
| */ |
| public boolean canJumpToAddress(BigInteger address) { |
| return getThread().canResume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IJumpToLine#canJumpToLine(org.eclipse |
| * .core.resources.IFile, int) |
| */ |
| public boolean canJumpToLine(IFile file, int lineNumber) { |
| return getThread().canResume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IJumpToLine#canJumpToLine(java.lang. |
| * String, int) |
| */ |
| public boolean canJumpToLine(String fileName, int lineNumber) { |
| return getThread().canResume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IRestart#canRestart() |
| */ |
| public boolean canRestart() { |
| return getDebugTarget() instanceof IRestart && ((IRestart) getDebugTarget()).canRestart(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ISuspendResume#canResume() |
| */ |
| public boolean canResume() { |
| return getThread().canResume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IResumeWithoutSignal#canResumeWithoutSignal |
| * () |
| */ |
| public boolean canResumeWithoutSignal() { |
| return (getDebugTarget() instanceof IResumeWithoutSignal && ((IResumeWithoutSignal) getDebugTarget()) |
| .canResumeWithoutSignal()); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IRunToAddress#canRunToAddress(java.math |
| * .BigInteger) |
| */ |
| public boolean canRunToAddress(BigInteger address) { |
| return getThread().canResume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IRunToLine#canRunToLine(org.eclipse. |
| * core.resources.IFile, int) |
| */ |
| public boolean canRunToLine(IFile file, int lineNumber) { |
| return getThread().canResume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IRunToLine#canRunToLine(java.lang.String |
| * , int) |
| */ |
| public boolean canRunToLine(String fileName, int lineNumber) { |
| return getThread().canResume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStep#canStepInto() |
| */ |
| public boolean canStepInto() { |
| try { |
| return exists() /* && isTopStackFrame() */&& getThread().canStepInto(); |
| } catch (DebugException e) { |
| logError(e); |
| return false; |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStep#canStepOver() |
| */ |
| public boolean canStepOver() { |
| try { |
| return exists() && getThread().canStepOver(); |
| } catch (DebugException e) { |
| logError(e); |
| } |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStep#canStepReturn() |
| */ |
| public boolean canStepReturn() { |
| try { |
| if (!exists()) { |
| return false; |
| } |
| List<IStackFrame> frames = ((PThread) getThread()).computeStackFrames(); |
| if (frames != null && !frames.isEmpty()) { |
| boolean bottomFrame = this.equals(frames.get(frames.size() - 1)); |
| return !bottomFrame && getThread().canStepReturn(); |
| } |
| } catch (DebugException e) { |
| logError(e); |
| } |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ISuspendResume#canSuspend() |
| */ |
| public boolean canSuspend() { |
| return getThread().canSuspend(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ITerminate#canTerminate() |
| */ |
| public boolean canTerminate() { |
| boolean exists = false; |
| try { |
| exists = exists(); |
| } catch (DebugException e) { |
| logError(e); |
| } |
| return exists && getThread().canTerminate() || getDebugTarget().canTerminate(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IPStackFrame#evaluateExpression(java |
| * .lang.String) |
| */ |
| public IValue evaluateExpression(String expressionText) throws DebugException { |
| if (!isDisposed()) { |
| PExpression expression = getExpression(expressionText); |
| if (expression != null) { |
| return expression.getValue(this); |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IPStackFrame#evaluateExpressionToString |
| * (java.lang.String) |
| */ |
| public String evaluateExpressionToString(String expression) throws DebugException { |
| try { |
| return getPDITarget().evaluateExpressionToString(getPDIStackFrame(), expression); |
| } catch (PDIException e) { |
| targetRequestFailed(e.getMessage(), null); |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.internal.core.model.PDebugElement#getAdapter(java |
| * .lang.Class) |
| */ |
| @SuppressWarnings("rawtypes") |
| @Override |
| public Object getAdapter(Class adapter) { |
| if (adapter == IRunToLine.class) { |
| return this; |
| } |
| if (adapter == IRunToAddress.class) { |
| return this; |
| } |
| if (adapter == IJumpToLine.class) { |
| return this; |
| } |
| if (adapter == IJumpToAddress.class) { |
| return this; |
| } |
| if (adapter == IPStackFrame.class) { |
| return this; |
| } |
| if (adapter == IStackFrame.class) { |
| return this; |
| } |
| if (adapter == IPDIStackFrame.class) { |
| return getPDIStackFrame(); |
| } |
| if (adapter == IMemoryBlockRetrieval.class) { |
| return getDebugTarget().getAdapter(adapter); |
| } |
| return super.getAdapter(adapter); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#getAddress() |
| */ |
| public BigInteger getAddress() { |
| return getPDIStackFrame().getLocator().getAddress(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#getCharEnd() |
| */ |
| public int getCharEnd() throws DebugException { |
| return -1; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#getCharStart() |
| */ |
| public int getCharStart() throws DebugException { |
| return -1; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.internal.core.model.PDebugElement#getDebugTarget() |
| */ |
| @Override |
| public PDebugTarget getDebugTarget() { |
| return fThread.getDebugTarget(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#getFile() |
| */ |
| public String getFile() { |
| return getPDIStackFrame().getLocator().getFile(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#getFrameLineNumber() |
| */ |
| public int getFrameLineNumber() { |
| return getPDIStackFrame().getLocator().getLineNumber(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#getFunction() |
| */ |
| public String getFunction() { |
| return getPDIStackFrame().getLocator().getFunction(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#getLevel() |
| */ |
| public int getLevel() { |
| return getPDIStackFrame().getLevel(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#getLineNumber() |
| */ |
| public int getLineNumber() throws DebugException { |
| if (isSuspended()) { |
| ISourceLocator locator = getLaunch().getSourceLocator(); |
| if (locator != null && locator instanceof IAdaptable |
| && ((IAdaptable) locator).getAdapter(IPSourceLocator.class) != null) |
| return ((IPSourceLocator) ((IAdaptable) locator).getAdapter(IPSourceLocator.class)).getLineNumber(this); |
| if (getPDIStackFrame() != null && getPDIStackFrame().getLocator() != null) |
| return getPDIStackFrame().getLocator().getLineNumber(); |
| } |
| return -1; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#getName() |
| */ |
| public String getName() throws DebugException { |
| IPDILocator locator = getPDIStackFrame().getLocator(); |
| String func = ""; //$NON-NLS-1$ |
| String file = ""; //$NON-NLS-1$ |
| String line = ""; //$NON-NLS-1$ |
| if (locator.getFunction() != null && locator.getFunction().trim().length() > 0) |
| func += locator.getFunction() + "() "; //$NON-NLS-1$ |
| if (locator.getFile() != null && locator.getFile().trim().length() > 0) { |
| file = locator.getFile(); |
| if (locator.getLineNumber() != 0) { |
| line = NumberFormat.getInstance().format(new Integer(locator.getLineNumber())); |
| } |
| } else { |
| return func; |
| } |
| return NLS.bind(Messages.PStackFrame_0, new Object[] { func, file, line }); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#getPDIStackFrame() |
| */ |
| public IPDIStackFrame getPDIStackFrame() { |
| return pdiStackFrame; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IPStackFrame#getPDIThread() |
| */ |
| public IPDIThread getPDIThread() { |
| return ((PThread) getThread()).getPDIThread(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#getRegisterGroups() |
| */ |
| public IRegisterGroup[] getRegisterGroups() throws DebugException { |
| return (isDisposed()) ? new IRegisterGroup[0] : fSession.getRegisterManager().getRegisterGroups(getTasks(), this); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#getThread() |
| */ |
| public IThread getThread() { |
| return fThread; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#getVariables() |
| */ |
| public IVariable[] getVariables() throws DebugException { |
| if (isDisposed()) { |
| return new IVariable[0]; |
| } |
| IPGlobalVariable[] globals = getGlobals(); |
| List<IPVariable> vars = getVariables0(); |
| List<IPVariable> all = new ArrayList<IPVariable>(globals.length + vars.size()); |
| all.addAll(Arrays.asList(globals)); |
| all.addAll(vars); |
| return all.toArray(new IVariable[all.size()]); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.pdi.event.IPDIEventListener#handleDebugEvents |
| * (org.eclipse.ptp.debug.core.pdi.event.IPDIEvent[]) |
| */ |
| public void handleDebugEvents(IPDIEvent[] events) { |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#hasRegisterGroups() |
| */ |
| public boolean hasRegisterGroups() throws DebugException { |
| return (isDisposed()) ? false |
| : getDebugTarget().fSession.getRegisterManager().getRegisterGroups(getTasks(), this).length > 0; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStackFrame#hasVariables() |
| */ |
| public boolean hasVariables() throws DebugException { |
| return getVariables0().size() > 0; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStep#isStepping() |
| */ |
| public boolean isStepping() { |
| return getThread().isStepping(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ISuspendResume#isSuspended() |
| */ |
| public boolean isSuspended() { |
| return getThread().isSuspended(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ITerminate#isTerminated() |
| */ |
| public boolean isTerminated() { |
| return getThread().isTerminated(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IJumpToAddress#jumpToAddress(java.math |
| * .BigInteger) |
| */ |
| public void jumpToAddress(BigInteger address) throws DebugException { |
| if (!canJumpToAddress(address)) |
| return; |
| |
| IPDILocation location = getPDISession().getBreakpointManager().createAddressLocation(address); |
| try { |
| getPDISession().resume(getTasks(), location); |
| } catch (PDIException e) { |
| targetRequestFailed(e.getMessage(), e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IJumpToLine#jumpToLine(org.eclipse.core |
| * .resources.IFile, int) |
| */ |
| public void jumpToLine(IFile file, int lineNumber) throws DebugException { |
| if (!canJumpToLine(file, lineNumber)) |
| return; |
| jumpToLine(file.getFullPath().lastSegment(), lineNumber); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IJumpToLine#jumpToLine(java.lang.String, |
| * int) |
| */ |
| public void jumpToLine(String fileName, int lineNumber) throws DebugException { |
| if (!canJumpToLine(fileName, lineNumber)) |
| return; |
| IPDILocation location = getPDISession().getBreakpointManager().createLineLocation(fileName, lineNumber); |
| try { |
| getPDISession().resume(getTasks(), location); |
| } catch (PDIException e) { |
| targetRequestFailed(e.getMessage(), e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ptp.debug.core.model.IRestart#restart() |
| */ |
| public void restart() throws DebugException { |
| if (canRestart()) { |
| ((IRestart) getDebugTarget()).restart(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ISuspendResume#resume() |
| */ |
| public void resume() throws DebugException { |
| getThread().resume(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IResumeWithoutSignal#resumeWithoutSignal |
| * () |
| */ |
| public void resumeWithoutSignal() throws DebugException { |
| if (canResumeWithoutSignal()) { |
| ((IResumeWithoutSignal) getDebugTarget()).resumeWithoutSignal(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IRunToAddress#runToAddress(java.math |
| * .BigInteger, boolean) |
| */ |
| public void runToAddress(BigInteger address, boolean skipBreakpoints) throws DebugException { |
| if (!canRunToAddress(address)) |
| return; |
| if (skipBreakpoints) { |
| fSession.getBreakpointManager().skipBreakpoints(true); |
| } |
| IPDILocation location = getPDISession().getBreakpointManager().createAddressLocation(address); |
| try { |
| getPDISession().stepUntil(getTasks(), location); |
| } catch (PDIException e) { |
| if (skipBreakpoints) { |
| fSession.getBreakpointManager().skipBreakpoints(false); |
| } |
| targetRequestFailed(e.getMessage(), e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IRunToLine#runToLine(org.eclipse.core |
| * .resources.IFile, int, boolean) |
| */ |
| public void runToLine(IFile file, int lineNumber, boolean skipBreakpoints) throws DebugException { |
| if (!canRunToLine(file, lineNumber)) |
| return; |
| runToLine(file.getLocation().lastSegment(), lineNumber, skipBreakpoints); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.ptp.debug.core.model.IRunToLine#runToLine(java.lang.String, |
| * int, boolean) |
| */ |
| public void runToLine(String fileName, int lineNumber, boolean skipBreakpoints) throws DebugException { |
| if (!canRunToLine(fileName, lineNumber)) |
| return; |
| if (skipBreakpoints) { |
| fSession.getBreakpointManager().skipBreakpoints(true); |
| } |
| IPDILocation location = getPDISession().getBreakpointManager().createLineLocation(fileName, lineNumber); |
| try { |
| getPDISession().stepUntil(getTasks(), location); |
| } catch (PDIException e) { |
| if (skipBreakpoints) { |
| fSession.getBreakpointManager().skipBreakpoints(false); |
| } |
| targetRequestFailed(e.getMessage(), e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStep#stepInto() |
| */ |
| public void stepInto() throws DebugException { |
| if (canStepInto()) { |
| getThread().stepInto(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStep#stepOver() |
| */ |
| public void stepOver() throws DebugException { |
| if (canStepOver()) { |
| getThread().stepOver(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.IStep#stepReturn() |
| */ |
| public void stepReturn() throws DebugException { |
| if (canStepReturn()) { |
| getThread().stepReturn(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ISuspendResume#suspend() |
| */ |
| public void suspend() throws DebugException { |
| getThread().suspend(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.debug.core.model.ITerminate#terminate() |
| */ |
| public void terminate() throws DebugException { |
| if (getThread().canTerminate()) { |
| getThread().terminate(); |
| } else { |
| getDebugTarget().terminate(); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see java.lang.Object#toString() |
| */ |
| @Override |
| public String toString() { |
| try { |
| return getName(); |
| } catch (DebugException e) { |
| return e.getLocalizedMessage(); |
| } |
| } |
| |
| /** |
| * @param expressionText |
| * @return |
| * @throws DebugException |
| */ |
| private synchronized PExpression getExpression(String expressionText) throws DebugException { |
| if (isDisposed()) { |
| return null; |
| } |
| if (fExpressions == null) { |
| fExpressions = new ArrayList<PExpression>(5); |
| } |
| PExpression expression = null; |
| Iterator<PExpression> it = fExpressions.iterator(); |
| while (it.hasNext()) { |
| expression = it.next(); |
| if (expression.getExpressionText().compareTo(expressionText) == 0) { |
| return expression; |
| } |
| } |
| try { |
| IPDITargetExpression pdiExpression = getPDISession().getExpressionManager() |
| .createExpression(getTasks(), expressionText); |
| expression = new PExpression(this, pdiExpression, null); |
| fExpressions.add(expression); |
| } catch (PDIException e) { |
| targetRequestFailed(e.getMessage(), null); |
| } |
| return expression; |
| } |
| |
| /** |
| * @return |
| */ |
| private IPGlobalVariable[] getGlobals() { |
| // TODO Not implement PStackFrame - getGlobals() yet |
| return new IPGlobalVariable[0]; |
| } |
| |
| /** |
| * |
| */ |
| private void preserveExpressions() { |
| if (fExpressions == null) |
| return; |
| Iterator<PExpression> it = fExpressions.iterator(); |
| while (it.hasNext()) { |
| PExpression exp = it.next(); |
| exp.preserve(); |
| } |
| } |
| |
| /** |
| * |
| */ |
| private void preserveVariables() { |
| if (fVariables == null) |
| return; |
| Iterator<IPVariable> it = fVariables.iterator(); |
| while (it.hasNext()) { |
| AbstractPVariable av = (AbstractPVariable) it.next(); |
| av.preserve(); |
| } |
| } |
| |
| /** |
| * @return |
| */ |
| private boolean refreshVariables() { |
| return fRefreshVariables; |
| } |
| |
| // FIXME - commented synchronized to prevent hanging here |
| /** |
| * @param isDisposed |
| */ |
| private/* synchronized */void setDisposed(boolean isDisposed) { |
| fIsDisposed = isDisposed; |
| } |
| |
| /** |
| * @param refresh |
| */ |
| private void setRefreshVariables(boolean refresh) { |
| fRefreshVariables = refresh; |
| } |
| |
| /** |
| * |
| */ |
| protected void dispose() { |
| setDisposed(true); |
| getPDISession().getEventManager().removeEventListener(this); |
| disposeAllVariables(); |
| disposeExpressions(); |
| } |
| |
| /** |
| * |
| */ |
| protected void disposeAllVariables() { |
| if (fVariables == null) |
| return; |
| Iterator<IPVariable> it = fVariables.iterator(); |
| while (it.hasNext()) { |
| ((PVariable) it.next()).dispose(); |
| } |
| fVariables.clear(); |
| fVariables = null; |
| } |
| |
| /** |
| * |
| */ |
| protected void disposeExpressions() { |
| if (fExpressions != null) { |
| Iterator<PExpression> it = fExpressions.iterator(); |
| while (it.hasNext()) { |
| (it.next()).dispose(); |
| } |
| fExpressions.clear(); |
| } |
| fExpressions = null; |
| } |
| |
| /** |
| * @throws DebugException |
| */ |
| protected void doStepReturn() throws DebugException { |
| try { |
| getPDISession().stepReturn(getTasks(), 0); |
| } catch (PDIException e) { |
| targetRequestFailed(e.getMessage(), null); |
| } |
| } |
| |
| /** |
| * @return |
| * @throws DebugException |
| */ |
| protected boolean exists() throws DebugException { |
| return ((PThread) getThread()).computeStackFrames().indexOf(this) != -1; |
| } |
| |
| /** |
| * @param list |
| * @param var |
| * @return |
| */ |
| protected IPDIVariableDescriptor findVariable(List<IPDIVariableDescriptor> list, PVariable var) { |
| Iterator<IPDIVariableDescriptor> it = list.iterator(); |
| while (it.hasNext()) { |
| IPDIVariableDescriptor newVarObject = it.next(); |
| if (var.sameVariable(newVarObject)) |
| return newVarObject; |
| } |
| return null; |
| } |
| |
| /** |
| * @return |
| * @throws DebugException |
| */ |
| protected List<IPDIVariableDescriptor> getAllPDIVariableObjects() throws DebugException { |
| List<IPDIVariableDescriptor> list = new ArrayList<IPDIVariableDescriptor>(); |
| list.addAll(getPDIArgumentObjects()); |
| list.addAll(getPDILocalVariableObjects()); |
| return list; |
| } |
| |
| /** |
| * @return |
| */ |
| protected IPDIStackFrame getLastPDIStackFrame() { |
| return lastPDIStackFrame; |
| } |
| |
| /** |
| * @return |
| * @throws DebugException |
| */ |
| protected List<IPDIVariableDescriptor> getPDIArgumentObjects() throws DebugException { |
| List<IPDIVariableDescriptor> list = new ArrayList<IPDIVariableDescriptor>(); |
| try { |
| list.addAll(Arrays.asList(getPDIStackFrame().getArgumentDescriptors())); |
| } catch (PDIException e) { |
| targetRequestFailed(e.getMessage(), null); |
| } |
| return list; |
| } |
| |
| /** |
| * @return |
| * @throws DebugException |
| */ |
| protected List<IPDIVariableDescriptor> getPDILocalVariableObjects() throws DebugException { |
| List<IPDIVariableDescriptor> list = new ArrayList<IPDIVariableDescriptor>(); |
| try { |
| list.addAll(Arrays.asList(getPDIStackFrame().getLocalVariableDescriptors())); |
| } catch (PDIException e) { |
| targetRequestFailed(e.getMessage(), null); |
| } |
| return list; |
| } |
| |
| /** |
| * @return |
| * @throws DebugException |
| */ |
| protected synchronized List<IPVariable> getVariables0() throws DebugException { |
| if (!isDisposed()) { |
| PThread thread = (PThread) getThread(); |
| if (thread.isSuspended()) { |
| if (fVariables == null) { |
| List<IPDIVariableDescriptor> vars = getAllPDIVariableObjects(); |
| fVariables = new ArrayList<IPVariable>(vars.size()); |
| Iterator<IPDIVariableDescriptor> it = vars.iterator(); |
| while (it.hasNext()) { |
| fVariables.add(PVariableFactory.createLocalVariable(this, it.next())); |
| } |
| } else { |
| if (refreshVariables()) { |
| updateVariables(); |
| } |
| } |
| setRefreshVariables(false); |
| } |
| if (fVariables != null) { |
| return fVariables; |
| } |
| } |
| return Collections.emptyList(); |
| } |
| |
| /** |
| * @return |
| */ |
| protected boolean isDisposed() { |
| return fIsDisposed; |
| } |
| |
| /** |
| * @return |
| * @throws DebugException |
| */ |
| protected boolean isTopStackFrame() throws DebugException { |
| IStackFrame tos = getThread().getTopStackFrame(); |
| return tos != null && tos.equals(this); |
| } |
| |
| /** |
| * |
| */ |
| protected synchronized void preserve() { |
| preserveVariables(); |
| preserveExpressions(); |
| } |
| |
| /** |
| * @param frame |
| */ |
| protected void setPDIStackFrame(IPDIStackFrame frame) { |
| if (frame != null) { |
| lastPDIStackFrame = frame; |
| } else { |
| lastPDIStackFrame = pdiStackFrame; |
| } |
| pdiStackFrame = frame; |
| setRefreshVariables(true); |
| } |
| |
| /** |
| * @param thread |
| */ |
| protected void setThread(PThread thread) { |
| fThread = thread; |
| } |
| |
| /** |
| * @throws DebugException |
| */ |
| protected void updateVariables() throws DebugException { |
| List<IPDIVariableDescriptor> locals = getAllPDIVariableObjects(); |
| int index = 0; |
| while (index < fVariables.size()) { |
| IPDIVariableDescriptor varObject = findVariable(locals, (PVariable) fVariables.get(index)); |
| if (varObject != null) { |
| locals.remove(varObject); |
| index++; |
| } else { |
| // remove variable |
| fVariables.remove(index); |
| } |
| } |
| // add any new locals |
| Iterator<IPDIVariableDescriptor> newOnes = locals.iterator(); |
| while (newOnes.hasNext()) { |
| fVariables.add(PVariableFactory.createLocalVariable(this, newOnes.next())); |
| } |
| } |
| } |
