mirror of
https://github.com/eclipse-cdt/cdt
synced 2025-04-29 19:45:01 +02:00
Bug 244336 Use the new --thread/--frame in a centralized location. Added supportsThreadAndFrameOptions() to MICommand to allow subclasses such as CLICommand and RawCommand to override and rely on -thread-select and -stack-select-frame.
Cleanup of MICommands that had --thread/--stack implemented directly in the class. MIStackNS is no longer needed, and its only remaining difference (checking if the thread is suspended) has been merged into MIStack.
This commit is contained in:
Marc Khouzam
parent
518693304f
commit
eba5a5fe78
25 changed files with 155 additions and 945 deletions
|
|
@ -72,8 +72,13 @@ public class GdbDebugServicesFactory extends AbstractDsfDebugServicesFactory {
|
|||
return new MIBreakpoints(session);
|
||||
}
|
||||
|
||||
protected ICommandControl createCommandControl(DsfSession session, ILaunchConfiguration config) {
|
||||
return new GDBControl(session, config);
|
||||
protected ICommandControl createCommandControl(DsfSession session, ILaunchConfiguration config) {
|
||||
boolean useThreadAndFrameOptions = false;
|
||||
if ("6.8".compareTo(fVersion) < 0) { //$NON-NLS-1$
|
||||
useThreadAndFrameOptions = true;
|
||||
}
|
||||
|
||||
return new GDBControl(session, config, useThreadAndFrameOptions);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -12,10 +12,8 @@ package org.eclipse.dd.gdb.internal.provisional.service;
|
|||
|
||||
import org.eclipse.dd.dsf.debug.service.IProcesses;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl;
|
||||
import org.eclipse.dd.dsf.debug.service.IStack;
|
||||
import org.eclipse.dd.dsf.service.DsfSession;
|
||||
import org.eclipse.dd.mi.service.MIRunControlNS;
|
||||
import org.eclipse.dd.mi.service.MIStackNS;
|
||||
|
||||
public class GdbDebugServicesFactoryNS extends GdbDebugServicesFactory {
|
||||
|
||||
|
|
@ -30,11 +28,6 @@ public class GdbDebugServicesFactoryNS extends GdbDebugServicesFactory {
|
|||
// }
|
||||
return new GDBProcesses(session);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected IStack createStackService(DsfSession session) {
|
||||
return new MIStackNS(session);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected IRunControl createRunControlService(DsfSession session) {
|
||||
|
|
|
|||
|
|
@ -120,8 +120,8 @@ public class GDBControl extends AbstractMIControl {
|
|||
|
||||
private PTY fPty;
|
||||
|
||||
public GDBControl(DsfSession session, ILaunchConfiguration config) {
|
||||
super(session, "gdbcontrol[" + ++fgInstanceCounter + "]"); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
public GDBControl(DsfSession session, ILaunchConfiguration config, boolean useThreadAndFrameOptions) {
|
||||
super(session, "gdbcontrol[" + ++fgInstanceCounter + "]", useThreadAndFrameOptions); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
fSessionType = LaunchUtils.getSessionType(config);
|
||||
fAttach = LaunchUtils.getIsAttach(config);
|
||||
fGdbPath = LaunchUtils.getGDBPath(config);
|
||||
|
|
@ -133,17 +133,6 @@ public class GDBControl extends AbstractMIControl {
|
|||
fControlDmc = new GDBControlDMContext(session.getId(), getId());
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public GDBControl(DsfSession session, IPath gdbPath, IPath execPath, SessionType sessionType, boolean attach, int gdbLaunchTimeout) {
|
||||
super(session, "gdbcontrol[" + ++fgInstanceCounter + "]"); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
fSessionType = sessionType;
|
||||
fAttach = attach;
|
||||
fGdbPath = gdbPath;
|
||||
fExecPath = execPath;
|
||||
fGDBLaunchTimeout = gdbLaunchTimeout;
|
||||
fControlDmc = new GDBControlDMContext(session.getId(), getId());
|
||||
}
|
||||
|
||||
@Override
|
||||
protected BundleContext getBundleContext() {
|
||||
return GdbPlugin.getBundleContext();
|
||||
|
|
|
|||
|
|
@ -389,11 +389,11 @@ public class MIRunControlNS extends AbstractDsfService implements IRunControl
|
|||
return;
|
||||
}
|
||||
|
||||
MIExecInterrupt cmd = new MIExecInterrupt(context, true);
|
||||
MIExecInterrupt cmd = new MIExecInterrupt(context);
|
||||
fConnection.queueCommand(cmd, new DataRequestMonitor<MIInfo>(getExecutor(), rm));
|
||||
}
|
||||
|
||||
private void doSuspendContainer(IExecutionDMContext context, final RequestMonitor rm) {
|
||||
private void doSuspendContainer(IContainerDMContext context, final RequestMonitor rm) {
|
||||
MIExecInterrupt cmd = new MIExecInterrupt(context, true);
|
||||
fConnection.queueCommand(cmd, new DataRequestMonitor<MIInfo>(getExecutor(), rm));
|
||||
}
|
||||
|
|
@ -475,7 +475,7 @@ public class MIRunControlNS extends AbstractDsfService implements IRunControl
|
|||
}
|
||||
threadState.fResumePending = true;
|
||||
|
||||
MIExecContinue cmd = new MIExecContinue(context, context.getThreadId());
|
||||
MIExecContinue cmd = new MIExecContinue(context);
|
||||
fConnection.queueCommand(cmd, new DataRequestMonitor<MIInfo>(getExecutor(), rm));
|
||||
}
|
||||
|
||||
|
|
@ -545,11 +545,11 @@ public class MIRunControlNS extends AbstractDsfService implements IRunControl
|
|||
|
||||
switch (stepType) {
|
||||
case STEP_INTO:
|
||||
fConnection.queueCommand(new MIExecStep(dmc, true),
|
||||
fConnection.queueCommand(new MIExecStep(dmc),
|
||||
new DataRequestMonitor<MIInfo>(getExecutor(), rm));
|
||||
break;
|
||||
case STEP_OVER:
|
||||
fConnection.queueCommand(new MIExecNext(dmc, true),
|
||||
fConnection.queueCommand(new MIExecNext(dmc),
|
||||
new DataRequestMonitor<MIInfo>(getExecutor(), rm));
|
||||
break;
|
||||
case STEP_RETURN:
|
||||
|
|
@ -571,11 +571,11 @@ public class MIRunControlNS extends AbstractDsfService implements IRunControl
|
|||
}
|
||||
break;
|
||||
case INSTRUCTION_STEP_INTO:
|
||||
fConnection.queueCommand(new MIExecStepInstruction(dmc, true),
|
||||
fConnection.queueCommand(new MIExecStepInstruction(dmc),
|
||||
new DataRequestMonitor<MIInfo>(getExecutor(), rm));
|
||||
break;
|
||||
case INSTRUCTION_STEP_OVER:
|
||||
fConnection.queueCommand(new MIExecNextInstruction(dmc, true),
|
||||
fConnection.queueCommand(new MIExecNextInstruction(dmc),
|
||||
new DataRequestMonitor<MIInfo>(getExecutor(), rm));
|
||||
break;
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ import org.eclipse.dd.dsf.concurrent.RequestMonitor;
|
|||
import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
|
||||
import org.eclipse.dd.dsf.datamodel.DMContexts;
|
||||
import org.eclipse.dd.dsf.datamodel.IDMContext;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl;
|
||||
import org.eclipse.dd.dsf.debug.service.IStack;
|
||||
import org.eclipse.dd.dsf.debug.service.IStack2;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
|
|
@ -123,6 +124,7 @@ public class MIStack extends AbstractDsfService
|
|||
|
||||
private CommandCache fMICommandCache;
|
||||
private MIStoppedEvent fCachedStoppedEvent;
|
||||
private IRunControl fRunControl;
|
||||
|
||||
public MIStack(DsfSession session)
|
||||
{
|
||||
|
|
@ -150,7 +152,8 @@ public class MIStack extends AbstractDsfService
|
|||
AbstractMIControl miControl = getServicesTracker().getService(AbstractMIControl.class);
|
||||
fMICommandCache = new CommandCache(getSession(), miControl);
|
||||
fMICommandCache.setContextAvailable(miControl.getControlDMContext(), true);
|
||||
|
||||
fRunControl = getServicesTracker().getService(IRunControl.class);
|
||||
|
||||
getSession().addServiceEventListener(this, null);
|
||||
register(new String[]{IStack.class.getName(), MIStack.class.getName()}, new Hashtable<String,String>());
|
||||
rm.done();
|
||||
|
|
@ -215,6 +218,13 @@ public class MIStack extends AbstractDsfService
|
|||
return;
|
||||
}
|
||||
|
||||
// Make sure the thread is stopped
|
||||
if (!fRunControl.isSuspended(execDmc)) {
|
||||
rm.setData(new IFrameDMContext[0]);
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
if (startIndex == 0 && endIndex == 0) {
|
||||
// Try to retrieve the top stack frame from the cached stopped event.
|
||||
if (fCachedStoppedEvent != null &&
|
||||
|
|
@ -604,19 +614,26 @@ public class MIStack extends AbstractDsfService
|
|||
public void getStackDepth(IDMContext dmc, final int maxDepth, final DataRequestMonitor<Integer> rm) {
|
||||
IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(dmc, IMIExecutionDMContext.class);
|
||||
if (execDmc != null) {
|
||||
MIStackInfoDepth depthCommand = null;
|
||||
if (maxDepth > 0) depthCommand = new MIStackInfoDepth(execDmc, maxDepth);
|
||||
else depthCommand = new MIStackInfoDepth(execDmc);
|
||||
|
||||
fMICommandCache.execute(
|
||||
depthCommand,
|
||||
new DataRequestMonitor<MIStackInfoDepthInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
rm.setData(getData().getDepth());
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
// Make sure the thread is stopped
|
||||
if (!fRunControl.isSuspended(execDmc)) {
|
||||
rm.setData(0);
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
MIStackInfoDepth depthCommand = null;
|
||||
if (maxDepth > 0) depthCommand = new MIStackInfoDepth(execDmc, maxDepth);
|
||||
else depthCommand = new MIStackInfoDepth(execDmc);
|
||||
|
||||
fMICommandCache.execute(
|
||||
depthCommand,
|
||||
new DataRequestMonitor<MIStackInfoDepthInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
rm.setData(getData().getDepth());
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context", null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
|
|
|
|||
|
|
@ -1,678 +0,0 @@
|
|||
/*******************************************************************************
|
||||
* Copyright (c) 2006, 2008 Wind River Systems 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:
|
||||
* Wind River Systems - initial API and implementation
|
||||
* Ericsson - Modified for handling of multiple execution contexts
|
||||
*******************************************************************************/
|
||||
package org.eclipse.dd.mi.service;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Hashtable;
|
||||
import java.util.List;
|
||||
|
||||
import org.eclipse.cdt.core.IAddress;
|
||||
import org.eclipse.cdt.utils.Addr32;
|
||||
import org.eclipse.cdt.utils.Addr64;
|
||||
import org.eclipse.core.runtime.IStatus;
|
||||
import org.eclipse.core.runtime.Status;
|
||||
import org.eclipse.dd.dsf.concurrent.CountingRequestMonitor;
|
||||
import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
|
||||
import org.eclipse.dd.dsf.concurrent.RequestMonitor;
|
||||
import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
|
||||
import org.eclipse.dd.dsf.datamodel.DMContexts;
|
||||
import org.eclipse.dd.dsf.datamodel.IDMContext;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl;
|
||||
import org.eclipse.dd.dsf.debug.service.IStack;
|
||||
import org.eclipse.dd.dsf.debug.service.IStack2;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IResumedDMEvent;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.ISuspendedDMEvent;
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.StateChangeReason;
|
||||
import org.eclipse.dd.dsf.debug.service.command.CommandCache;
|
||||
import org.eclipse.dd.dsf.service.AbstractDsfService;
|
||||
import org.eclipse.dd.dsf.service.DsfServiceEventHandler;
|
||||
import org.eclipse.dd.dsf.service.DsfSession;
|
||||
import org.eclipse.dd.mi.internal.MIPlugin;
|
||||
import org.eclipse.dd.mi.service.command.AbstractMIControl;
|
||||
import org.eclipse.dd.mi.service.command.commands.MIStackInfoDepth;
|
||||
import org.eclipse.dd.mi.service.command.commands.MIStackListArguments;
|
||||
import org.eclipse.dd.mi.service.command.commands.MIStackListFrames;
|
||||
import org.eclipse.dd.mi.service.command.commands.MIStackListLocals;
|
||||
import org.eclipse.dd.mi.service.command.events.IMIDMEvent;
|
||||
import org.eclipse.dd.mi.service.command.events.MIEvent;
|
||||
import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;
|
||||
import org.eclipse.dd.mi.service.command.output.MIArg;
|
||||
import org.eclipse.dd.mi.service.command.output.MIFrame;
|
||||
import org.eclipse.dd.mi.service.command.output.MIStackInfoDepthInfo;
|
||||
import org.eclipse.dd.mi.service.command.output.MIStackListArgumentsInfo;
|
||||
import org.eclipse.dd.mi.service.command.output.MIStackListFramesInfo;
|
||||
import org.eclipse.dd.mi.service.command.output.MIStackListLocalsInfo;
|
||||
import org.osgi.framework.BundleContext;
|
||||
|
||||
public class MIStackNS extends AbstractDsfService
|
||||
implements IStack2
|
||||
{
|
||||
protected static class MIFrameDMC extends AbstractDMContext
|
||||
implements IFrameDMContext
|
||||
{
|
||||
private final int fLevel;
|
||||
// public MIFrameDMC(MIStack service, int level) {
|
||||
public MIFrameDMC(String sessionId, IExecutionDMContext execDmc, int level) {
|
||||
super(sessionId, new IDMContext[] { execDmc });
|
||||
fLevel = level;
|
||||
}
|
||||
|
||||
public int getLevel() { return fLevel; }
|
||||
|
||||
@Override
|
||||
public boolean equals(Object other) {
|
||||
return super.baseEquals(other) && ((MIFrameDMC)other).fLevel == fLevel;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return super.baseHashCode() ^ fLevel;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return baseToString() + ".frame[" + fLevel + "]"; //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
}
|
||||
|
||||
protected static class MIVariableDMC extends AbstractDMContext
|
||||
implements IVariableDMContext
|
||||
{
|
||||
public enum Type { ARGUMENT, LOCAL }
|
||||
final private Type fType;
|
||||
final private int fIndex;
|
||||
|
||||
public MIVariableDMC(MIStackNS service, IFrameDMContext frame, Type type, int index) {
|
||||
super(service, new IDMContext[] { frame });
|
||||
fIndex = index;
|
||||
fType = type;
|
||||
}
|
||||
|
||||
public int getIndex() { return fIndex; }
|
||||
public Type getType() { return fType; }
|
||||
|
||||
@Override
|
||||
public boolean equals(Object other) {
|
||||
return super.baseEquals(other) &&
|
||||
((MIVariableDMC)other).fType == fType &&
|
||||
((MIVariableDMC)other).fIndex == fIndex;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int typeFactor = 0;
|
||||
if (fType == Type.LOCAL) typeFactor = 2;
|
||||
else if (fType == Type.ARGUMENT) typeFactor = 3;
|
||||
return super.baseHashCode() ^ typeFactor ^ fIndex;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return baseToString() + ".variable(" + fType + ")[" + fIndex + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
|
||||
}
|
||||
}
|
||||
|
||||
private CommandCache fMICommandCache;
|
||||
private MIStoppedEvent fCachedStoppedEvent;
|
||||
private IRunControl fRunControl;
|
||||
|
||||
public MIStackNS(DsfSession session)
|
||||
{
|
||||
super(session);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected BundleContext getBundleContext()
|
||||
{
|
||||
return MIPlugin.getBundleContext();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initialize(final RequestMonitor rm) {
|
||||
super.initialize(
|
||||
new RequestMonitor(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
doInitialize(rm);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private void doInitialize(RequestMonitor rm) {
|
||||
AbstractMIControl miControl = getServicesTracker().getService(AbstractMIControl.class);
|
||||
fMICommandCache = new CommandCache(getSession(), miControl);
|
||||
fMICommandCache.setContextAvailable(miControl.getControlDMContext(), true);
|
||||
fRunControl = getServicesTracker().getService(IRunControl.class);
|
||||
|
||||
getSession().addServiceEventListener(this, null);
|
||||
register(new String[]{IStack.class.getName(), MIStackNS.class.getName()}, new Hashtable<String,String>());
|
||||
rm.done();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void shutdown(RequestMonitor rm)
|
||||
{
|
||||
unregister();
|
||||
getSession().removeServiceEventListener(this);
|
||||
fMICommandCache.reset();
|
||||
super.shutdown(rm);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public void getModelData(IDMContext dmc, DataRequestMonitor<?> rm) {
|
||||
if (dmc instanceof MIFrameDMC) {
|
||||
getFrameData((MIFrameDMC)dmc, (DataRequestMonitor<IFrameDMData>)rm);
|
||||
// getFrameData invokes rm
|
||||
} else if (dmc instanceof MIVariableDMC) {
|
||||
getVariableData((MIVariableDMC)dmc, (DataRequestMonitor<IVariableDMData>)rm);
|
||||
// getVariablesData invokes rm
|
||||
} else {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Unknown DMC type", null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a frame context. This method is intended to be used by other MI
|
||||
* services and sub-classes which need to create a frame context directly.
|
||||
* <p>
|
||||
* Sub-classes can override this method to provide custom stack frame
|
||||
* context implementation.
|
||||
* </p>
|
||||
* @param execDmc Execution context that this frame is to be a child of.
|
||||
* @param level Level of the new context.
|
||||
* @return A new frame context.
|
||||
*/
|
||||
public IFrameDMContext createFrameDMContext(IExecutionDMContext execDmc, int level) {
|
||||
return new MIFrameDMC(getSession().getId(), execDmc, level);
|
||||
}
|
||||
|
||||
public void getFrames(final IDMContext ctx, final DataRequestMonitor<IFrameDMContext[]> rm) {
|
||||
getFrames(ctx, 0, ALL_FRAMES, rm);
|
||||
}
|
||||
|
||||
public void getFrames(final IDMContext ctx, final int startIndex, final int endIndex, final DataRequestMonitor<IFrameDMContext[]> rm) {
|
||||
|
||||
// Make sure we have an execution context (ideally a thread)
|
||||
final IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(ctx, IMIExecutionDMContext.class);
|
||||
if (execDmc == null) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context " + ctx, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Make sure the indices are OK
|
||||
if (startIndex < 0 || endIndex > 0 && endIndex < startIndex) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid stack frame range [" + startIndex + ',' + endIndex + ']', null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Make sure the thread is stopped
|
||||
if (!fRunControl.isSuspended(execDmc)) {
|
||||
rm.setData(new IFrameDMContext[0]);
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Case of retrieving the top stack frame from the cached stopped event.
|
||||
if (startIndex == 0 && endIndex == 0) {
|
||||
if (fCachedStoppedEvent != null && fCachedStoppedEvent.getFrame() != null &&
|
||||
execDmc.equals(fCachedStoppedEvent.getDMContext()))
|
||||
{
|
||||
rm.setData(new IFrameDMContext[] { createFrameDMContext(execDmc, fCachedStoppedEvent.getFrame().getLevel()) });
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Select the proper MI command variant
|
||||
final MIStackListFrames miStackListCmd;
|
||||
final int firstIndex;
|
||||
if (endIndex >= 0) {
|
||||
miStackListCmd = new MIStackListFrames(execDmc, true, startIndex, endIndex);
|
||||
firstIndex = startIndex;
|
||||
} else {
|
||||
miStackListCmd = new MIStackListFrames(execDmc, true);
|
||||
firstIndex = 0;
|
||||
}
|
||||
|
||||
// And go...
|
||||
fMICommandCache.execute(
|
||||
miStackListCmd,
|
||||
new DataRequestMonitor<MIStackListFramesInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
rm.setData(getFrames(execDmc, getData(), firstIndex, endIndex, startIndex));
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void getTopFrame(final IDMContext ctx, final DataRequestMonitor<IFrameDMContext> rm) {
|
||||
final IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(ctx, IMIExecutionDMContext.class);
|
||||
if (execDmc == null) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context" + ctx, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Try to retrieve the top stack frame from the cached stopped event.
|
||||
if (fCachedStoppedEvent != null &&
|
||||
fCachedStoppedEvent.getFrame() != null &&
|
||||
execDmc.equals(fCachedStoppedEvent.getDMContext()))
|
||||
{
|
||||
rm.setData(createFrameDMContext(execDmc, fCachedStoppedEvent.getFrame().getLevel()));
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// If stopped event is not available or doesn't contain frame info,
|
||||
// query top stack frame
|
||||
getFrames(
|
||||
ctx,
|
||||
0,
|
||||
0,
|
||||
new DataRequestMonitor<IFrameDMContext[]>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
rm.setData(getData()[0]);
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
//private MIFrameDMC[] getFrames(DsfMIStackListFramesInfo info) {
|
||||
private IFrameDMContext[] getFrames(IMIExecutionDMContext execDmc, MIStackListFramesInfo info, int firstIndex, int lastIndex, int startIndex) {
|
||||
int length = info.getMIFrames().length;
|
||||
if (lastIndex > 0) {
|
||||
int limit= lastIndex - startIndex + 1;
|
||||
if (limit < length) {
|
||||
length = limit;
|
||||
}
|
||||
}
|
||||
IFrameDMContext[] frameDMCs = new MIFrameDMC[length];
|
||||
for (int i = 0; i < length; i++) {
|
||||
//frameDMCs[i] = new MIFrameDMC(this, info.getMIFrames()[i].getLevel());
|
||||
final MIFrame frame= info.getMIFrames()[i + startIndex - firstIndex];
|
||||
assert startIndex + i == frame.getLevel();
|
||||
frameDMCs[i] = createFrameDMContext(execDmc, frame.getLevel());
|
||||
}
|
||||
return frameDMCs;
|
||||
}
|
||||
|
||||
|
||||
|
||||
public void getFrameData(final IFrameDMContext frameDmc, final DataRequestMonitor<IFrameDMData> rm) {
|
||||
if (!(frameDmc instanceof MIFrameDMC)) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context type " + frameDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
final MIFrameDMC miFrameDmc = (MIFrameDMC)frameDmc;
|
||||
|
||||
IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(frameDmc, IMIExecutionDMContext.class);
|
||||
if (execDmc == null) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "No execution context found in " + frameDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* Base class for the IFrameDMData object that uses an MIFrame object to
|
||||
* provide the data. Sub-classes must provide the MIFrame object
|
||||
*/
|
||||
abstract class FrameData implements IFrameDMData
|
||||
{
|
||||
abstract protected MIFrame getMIFrame();
|
||||
|
||||
public IAddress getAddress() {
|
||||
String addr = getMIFrame().getAddress();
|
||||
if (addr.startsWith("0x")) { //$NON-NLS-1$
|
||||
addr = addr.substring(2);
|
||||
}
|
||||
if (addr.length() <= 8) {
|
||||
return new Addr32(getMIFrame().getAddress());
|
||||
} else {
|
||||
return new Addr64(getMIFrame().getAddress());
|
||||
}
|
||||
}
|
||||
|
||||
public int getColumn() { return 0; }
|
||||
|
||||
public String getFile() { return getMIFrame().getFile(); }
|
||||
public int getLine() { return getMIFrame().getLine(); }
|
||||
public String getFunction() { return getMIFrame().getFunction(); }
|
||||
|
||||
@Override
|
||||
public String toString() { return getMIFrame().toString(); }
|
||||
}
|
||||
|
||||
// If requested frame is the top stack frame, try to retrieve it from
|
||||
// the stopped event data.
|
||||
class FrameDataFromStoppedEvent extends FrameData {
|
||||
private final MIStoppedEvent fEvent;
|
||||
FrameDataFromStoppedEvent(MIStoppedEvent event) { fEvent = event; }
|
||||
@Override
|
||||
protected MIFrame getMIFrame() { return fEvent.getFrame(); }
|
||||
}
|
||||
|
||||
// Retrieve the top stack frame from the stopped event only if the selected thread is the one on which stopped event
|
||||
// is raised
|
||||
if (fCachedStoppedEvent != null &&
|
||||
execDmc.equals(fCachedStoppedEvent.getDMContext()) &&
|
||||
miFrameDmc.fLevel == 0 &&
|
||||
fCachedStoppedEvent.getFrame() != null)
|
||||
{
|
||||
rm.setData(new FrameDataFromStoppedEvent(fCachedStoppedEvent));
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// If not, retrieve the full list of frame data.
|
||||
class FrameDataFromMIStackFrameListInfo extends FrameData {
|
||||
private MIStackListFramesInfo fFrameDataCacheInfo;
|
||||
private int fFrameIndex;
|
||||
|
||||
FrameDataFromMIStackFrameListInfo(MIStackListFramesInfo info, int index) {
|
||||
fFrameDataCacheInfo = info;
|
||||
fFrameIndex = index;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected MIFrame getMIFrame() { return fFrameDataCacheInfo.getMIFrames()[fFrameIndex]; }
|
||||
}
|
||||
|
||||
fMICommandCache.execute(
|
||||
new MIStackListFrames(execDmc, true),
|
||||
new DataRequestMonitor<MIStackListFramesInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
// Find the index to the correct MI frame object.
|
||||
int idx = findFrameIndex(getData().getMIFrames(), miFrameDmc.fLevel);
|
||||
if (idx == -1) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid frame " + frameDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Create the data object.
|
||||
rm.setData(new FrameDataFromMIStackFrameListInfo(getData(), idx));
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void getArguments(final IFrameDMContext frameDmc, final DataRequestMonitor<IVariableDMContext[]> rm) {
|
||||
final IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(frameDmc, IMIExecutionDMContext.class);
|
||||
if (execDmc == null) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "No execution context found in " + frameDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// If requested frame is the top stack frame, try to retrieve it from
|
||||
// the stopped event data.
|
||||
if (frameDmc.getLevel() == 0 &&
|
||||
fCachedStoppedEvent != null &&
|
||||
fCachedStoppedEvent.getFrame() != null &&
|
||||
execDmc.equals(fCachedStoppedEvent.getDMContext()) &&
|
||||
fCachedStoppedEvent.getFrame().getArgs() != null)
|
||||
{
|
||||
rm.setData(makeVariableDMCs(
|
||||
frameDmc, MIVariableDMC.Type.ARGUMENT, fCachedStoppedEvent.getFrame().getArgs().length));
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// If not, retrieve the full list of frame data.
|
||||
fMICommandCache.execute(
|
||||
new MIStackListArguments(execDmc, true, true),
|
||||
new DataRequestMonitor<MIStackListArgumentsInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
// Find the index to the correct MI frame object.
|
||||
// Note: this is a short-cut, but it won't work once we implement retrieving
|
||||
// partial lists of stack frames.
|
||||
int idx = frameDmc.getLevel();
|
||||
if (idx == -1 || idx >= getData().getMIFrames().length) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_STATE, "Invalid frame " + frameDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Create the variable array out of MIArg array.
|
||||
MIArg[] args = getData().getMIFrames()[idx].getArgs();
|
||||
if (args == null) args = new MIArg[0];
|
||||
rm.setData(makeVariableDMCs(frameDmc, MIVariableDMC.Type.ARGUMENT, args.length));
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void getVariableData(IVariableDMContext variableDmc, final DataRequestMonitor<IVariableDMData> rm) {
|
||||
if (!(variableDmc instanceof MIVariableDMC)) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context type " + variableDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
final MIVariableDMC miVariableDmc = (MIVariableDMC)variableDmc;
|
||||
|
||||
// Extract the frame DMC from the variable DMC.
|
||||
final MIFrameDMC frameDmc = DMContexts.getAncestorOfType(variableDmc, MIFrameDMC.class);
|
||||
if (frameDmc == null) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "No frame context found in " + variableDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
final IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(frameDmc, IMIExecutionDMContext.class);
|
||||
if (execDmc == null) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "No execution context found in " + frameDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* Same as with frame objects, this is a base class for the IVariableDMData object that uses an MIArg object to
|
||||
* provide the data. Sub-classes must supply the MIArg object.
|
||||
*/
|
||||
class VariableData implements IVariableDMData {
|
||||
private MIArg dsfMIArg;
|
||||
VariableData(MIArg arg){
|
||||
dsfMIArg = arg;
|
||||
}
|
||||
public String getName() { return dsfMIArg.getName(); }
|
||||
public String getValue() { return dsfMIArg.getValue(); }
|
||||
@Override
|
||||
public String toString() { return dsfMIArg.toString(); }
|
||||
}
|
||||
|
||||
// Check if the stopped event can be used to extract the variable value.
|
||||
if (execDmc != null && miVariableDmc.fType == MIVariableDMC.Type.ARGUMENT &&
|
||||
frameDmc.fLevel == 0 && fCachedStoppedEvent != null && fCachedStoppedEvent.getFrame() != null &&
|
||||
execDmc.equals(fCachedStoppedEvent.getDMContext()) &&
|
||||
fCachedStoppedEvent.getFrame().getArgs() != null)
|
||||
{
|
||||
if (miVariableDmc.fIndex >= fCachedStoppedEvent.getFrame().getArgs().length) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, -1, "Invalid variable " + miVariableDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
rm.setData(new VariableData(fCachedStoppedEvent.getFrame().getArgs()[miVariableDmc.fIndex]));
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
if (miVariableDmc.fType == MIVariableDMC.Type.ARGUMENT){
|
||||
fMICommandCache.execute(
|
||||
new MIStackListArguments(execDmc, true, true),
|
||||
new DataRequestMonitor<MIStackListArgumentsInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
// Find the correct frame and argument
|
||||
if ( frameDmc.fLevel >= getData().getMIFrames().length ||
|
||||
miVariableDmc.fIndex >= getData().getMIFrames()[frameDmc.fLevel].getArgs().length )
|
||||
{
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid variable " + miVariableDmc, null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Create the data object.
|
||||
rm.setData(new VariableData(getData().getMIFrames()[frameDmc.fLevel].getArgs()[miVariableDmc.fIndex]));
|
||||
rm.done();
|
||||
}});
|
||||
}//if
|
||||
if (miVariableDmc.fType == MIVariableDMC.Type.LOCAL){
|
||||
fMICommandCache.execute(
|
||||
new MIStackListLocals(frameDmc, true, true),
|
||||
new DataRequestMonitor<MIStackListLocalsInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
|
||||
// Create the data object.
|
||||
MIArg[] locals = getData().getLocals();
|
||||
if (locals.length > miVariableDmc.fIndex) {
|
||||
rm.setData(new VariableData(locals[miVariableDmc.fIndex]));
|
||||
} else {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid variable " + miVariableDmc, null)); //$NON-NLS-1$
|
||||
}
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
|
||||
}//if
|
||||
|
||||
}
|
||||
|
||||
private MIVariableDMC[] makeVariableDMCs(IFrameDMContext frame, MIVariableDMC.Type type, int count) {
|
||||
MIVariableDMC[] variables = new MIVariableDMC[count];
|
||||
for (int i = 0; i < count; i++) {
|
||||
variables[i]= new MIVariableDMC(this, frame, type, i);
|
||||
}
|
||||
return variables;
|
||||
}
|
||||
|
||||
private int findFrameIndex(MIFrame[] frames, int level) {
|
||||
for (int idx = 0; idx < frames.length; idx++) {
|
||||
if (frames[idx].getLevel() == level) {
|
||||
return idx;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
public void getLocals(final IFrameDMContext frameDmc, final DataRequestMonitor<IVariableDMContext[]> rm) {
|
||||
|
||||
final List<IVariableDMContext> localsList = new ArrayList<IVariableDMContext>();
|
||||
|
||||
final CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
rm.setData( localsList.toArray(new IVariableDMContext[localsList.size()]) );
|
||||
rm.done();
|
||||
}
|
||||
};
|
||||
countingRm.setDoneCount(2);
|
||||
|
||||
getArguments(
|
||||
frameDmc,
|
||||
new DataRequestMonitor<IVariableDMContext[]>(getExecutor(), countingRm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
localsList.addAll( Arrays.asList(getData()) );
|
||||
countingRm.done();
|
||||
}
|
||||
});
|
||||
|
||||
fMICommandCache.execute(
|
||||
new MIStackListLocals(frameDmc, true, true),
|
||||
new DataRequestMonitor<MIStackListLocalsInfo>(getExecutor(), countingRm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
localsList.addAll( Arrays.asList(
|
||||
makeVariableDMCs(frameDmc, MIVariableDMC.Type.LOCAL, getData().getLocals().length)) );
|
||||
countingRm.done();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void getStackDepth(IDMContext dmc, final int maxDepth, final DataRequestMonitor<Integer> rm) {
|
||||
|
||||
// Make sure we have an execution context (ideally a thread)
|
||||
final IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(dmc, IMIExecutionDMContext.class);
|
||||
if (execDmc == null) {
|
||||
rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context", null)); //$NON-NLS-1$
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Make sure the thread is stopped
|
||||
if (!fRunControl.isSuspended(execDmc)) {
|
||||
rm.setData(0);
|
||||
rm.done();
|
||||
return;
|
||||
}
|
||||
|
||||
// Select the proper MI command variant
|
||||
MIStackInfoDepth depthCommand = null;
|
||||
if (maxDepth > 0) {
|
||||
depthCommand = new MIStackInfoDepth(execDmc, true, maxDepth);
|
||||
}
|
||||
else {
|
||||
depthCommand = new MIStackInfoDepth(execDmc);
|
||||
}
|
||||
|
||||
// And go...
|
||||
fMICommandCache.execute(
|
||||
depthCommand,
|
||||
new DataRequestMonitor<MIStackInfoDepthInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
protected void handleSuccess() {
|
||||
rm.setData(getData().getDepth());
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// IServiceEventListener
|
||||
@DsfServiceEventHandler
|
||||
public void eventDispatched(IResumedDMEvent e) {
|
||||
fMICommandCache.setContextAvailable(e.getDMContext(), false);
|
||||
if (e.getReason() != StateChangeReason.STEP) {
|
||||
fCachedStoppedEvent = null;
|
||||
fMICommandCache.reset();
|
||||
}
|
||||
}
|
||||
|
||||
@DsfServiceEventHandler
|
||||
public void eventDispatched(ISuspendedDMEvent e) {
|
||||
fMICommandCache.setContextAvailable(e.getDMContext(), true);
|
||||
fMICommandCache.reset();
|
||||
}
|
||||
|
||||
@DsfServiceEventHandler
|
||||
public void eventDispatched(IMIDMEvent e) {
|
||||
MIEvent<? extends IDMContext> miEvent = e.getMIEvent();
|
||||
if (miEvent instanceof MIStoppedEvent) {
|
||||
fCachedStoppedEvent = (MIStoppedEvent)miEvent;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -75,8 +75,13 @@ public abstract class AbstractMIControl extends AbstractDsfService
|
|||
private TxThread fTxThread;
|
||||
private RxThread fRxThread;
|
||||
|
||||
private int fCurrentStackLevel = -1;
|
||||
private int fCurrentThreadId = -1;
|
||||
// MI did not always support the --thread/--frame options
|
||||
// This boolean is used to know if we should use -thread-select and -stack-select-frame instead
|
||||
private boolean fUseThreadAndFrameOptions;
|
||||
// currentStackLevel and currentThreadId are only necessary when
|
||||
// we must use -thread-select and -stack-select-frame
|
||||
private int fCurrentStackLevel = -1;
|
||||
private String fCurrentThreadId = null;
|
||||
|
||||
|
||||
private final BlockingQueue<CommandHandle> fTxCommands = new LinkedBlockingQueue<CommandHandle>();
|
||||
|
|
@ -112,11 +117,13 @@ public abstract class AbstractMIControl extends AbstractDsfService
|
|||
public AbstractMIControl(DsfSession session) {
|
||||
super(session);
|
||||
fId = "<no id>"; //$NON-NLS-1$
|
||||
fUseThreadAndFrameOptions = false;
|
||||
}
|
||||
|
||||
public AbstractMIControl(DsfSession session, String id) {
|
||||
public AbstractMIControl(DsfSession session, String id, boolean useThreadAndFrameOptions) {
|
||||
super(session);
|
||||
fId = id;
|
||||
fUseThreadAndFrameOptions = useThreadAndFrameOptions;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -250,36 +257,42 @@ public abstract class AbstractMIControl extends AbstractDsfService
|
|||
if (handle != null) {
|
||||
processCommandSent(handle);
|
||||
|
||||
// Identify target thread/frame (we might have to update them at the target)
|
||||
final IDMContext targetContext = handle.fCommand.getContext();
|
||||
final int targetThread = (handle.getThreadId() != null) ? handle.getThreadId().intValue() : -1;
|
||||
final int targetFrame = (handle.getStackFrameId() != null) ? handle.getStackFrameId().intValue() : -1;
|
||||
// Older debuggers didn't support the --thread/--frame options
|
||||
// Also, not all commands support those options (e.g., CLI commands)
|
||||
if (!fUseThreadAndFrameOptions || !handle.getCommand().supportsThreadAndFrameOptions()) {
|
||||
// Without the --thread/--frame, we need to send the proper
|
||||
// -thread-select and -stack-frame-select before sending the command
|
||||
|
||||
final IDMContext targetContext = handle.fCommand.getContext();
|
||||
final String targetThread = handle.getThreadId();
|
||||
final int targetFrame = handle.getStackFrameId();
|
||||
|
||||
// The thread-select and frame-select make sense only if the thread is stopped.
|
||||
// Some non-stop commands don't require the thread to be stopped so we send the
|
||||
// command anyway.
|
||||
IRunControl runControl = getServicesTracker().getService(IRunControl.class);
|
||||
IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(targetContext, IMIExecutionDMContext.class);
|
||||
if (runControl != null && execDmc != null && runControl.isSuspended(execDmc)) {
|
||||
// Before the command is sent, Check the Thread Id and send it to
|
||||
// the queue only if the id has been changed.
|
||||
if (targetThread > 0 && targetThread != fCurrentThreadId) {
|
||||
fCurrentThreadId = targetThread;
|
||||
resetCurrentStackLevel();
|
||||
CommandHandle cmdHandle = new CommandHandle(new MIThreadSelect(execDmc), null);
|
||||
cmdHandle.generateTokenId();
|
||||
fTxCommands.add(cmdHandle);
|
||||
}
|
||||
// The thread-select and frame-select make sense only if the thread is stopped.
|
||||
IRunControl runControl = getServicesTracker().getService(IRunControl.class);
|
||||
IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(targetContext, IMIExecutionDMContext.class);
|
||||
if (runControl != null && execDmc != null && runControl.isSuspended(execDmc)) {
|
||||
// Before the command is sent, Check the Thread Id and send it to
|
||||
// the queue only if the id has been changed. Also, don't send a threadId of 0,
|
||||
// because that id is only used internally for single-threaded programs
|
||||
if (targetThread != null && !targetThread.equals("0") && !targetThread.equals(fCurrentThreadId)) { //$NON-NLS-1$
|
||||
fCurrentThreadId = targetThread;
|
||||
resetCurrentStackLevel();
|
||||
CommandHandle cmdHandle = new CommandHandle(new MIThreadSelect(targetContext, targetThread), null);
|
||||
cmdHandle.generateTokenId();
|
||||
fTxCommands.add(cmdHandle);
|
||||
}
|
||||
|
||||
// Before the command is sent, Check the Stack level and send it to
|
||||
// the queue only if the level has been changed.
|
||||
if (targetFrame != -1 && targetFrame != fCurrentStackLevel) {
|
||||
fCurrentStackLevel = targetFrame;
|
||||
CommandHandle cmdHandle = new CommandHandle(new MIStackSelectFrame(execDmc, targetFrame), null);
|
||||
cmdHandle.generateTokenId();
|
||||
fTxCommands.add(cmdHandle);
|
||||
}
|
||||
// Before the command is sent, Check the Stack level and send it to
|
||||
// the queue only if the level has been changed.
|
||||
if (targetFrame >= 0 && targetFrame != fCurrentStackLevel) {
|
||||
fCurrentStackLevel = targetFrame;
|
||||
CommandHandle cmdHandle = new CommandHandle(new MIStackSelectFrame(targetContext, targetFrame), null);
|
||||
cmdHandle.generateTokenId();
|
||||
fTxCommands.add(cmdHandle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
handle.generateTokenId();
|
||||
fTxCommands.add(handle);
|
||||
}
|
||||
|
|
@ -449,18 +462,17 @@ public abstract class AbstractMIControl extends AbstractDsfService
|
|||
public void generateTokenId() { fTokenId = getNewTokenId(); }
|
||||
public Integer getTokenId() { return fTokenId; }
|
||||
|
||||
//public String getThreadId() { return null; }
|
||||
public Integer getStackFrameId() {
|
||||
public int getStackFrameId() {
|
||||
IFrameDMContext frameCtx = DMContexts.getAncestorOfType(fCommand.getContext(), IFrameDMContext.class);
|
||||
if(frameCtx != null)
|
||||
return frameCtx.getLevel();
|
||||
return null;
|
||||
return -1;
|
||||
}
|
||||
|
||||
public Integer getThreadId() {
|
||||
public String getThreadId() {
|
||||
IMIExecutionDMContext execCtx = DMContexts.getAncestorOfType(fCommand.getContext(), IMIExecutionDMContext.class);
|
||||
if(execCtx != null)
|
||||
return execCtx.getThreadId();
|
||||
return Integer.toString(execCtx.getThreadId());
|
||||
return null;
|
||||
}
|
||||
|
||||
|
|
@ -516,8 +528,15 @@ public abstract class AbstractMIControl extends AbstractDsfService
|
|||
/*
|
||||
* Construct the new command and push this command out the pipeline.
|
||||
*/
|
||||
|
||||
final String str = commandHandle.getTokenId() + commandHandle.getCommand().constructCommand();
|
||||
|
||||
final String str;
|
||||
// Not all commands support the --thread/--frame options (e.g., CLI commands)
|
||||
if (fUseThreadAndFrameOptions && commandHandle.getCommand().supportsThreadAndFrameOptions()) {
|
||||
str = commandHandle.getTokenId() + commandHandle.getCommand().constructCommand(commandHandle.getThreadId(),
|
||||
commandHandle.getStackFrameId());
|
||||
} else {
|
||||
str = commandHandle.getTokenId() + commandHandle.getCommand().constructCommand();
|
||||
}
|
||||
|
||||
try {
|
||||
if (fOutputStream != null) {
|
||||
|
|
@ -763,8 +782,10 @@ public abstract class AbstractMIControl extends AbstractDsfService
|
|||
}
|
||||
}
|
||||
|
||||
// we keep track of currentStackLevel and currentThreadId because in
|
||||
// some cases we must use -thread-select and -stack-select-frame
|
||||
public void resetCurrentThreadLevel(){
|
||||
fCurrentThreadId = -1;
|
||||
fCurrentThreadId = null;
|
||||
}
|
||||
|
||||
public void resetCurrentStackLevel(){
|
||||
|
|
|
|||
|
|
@ -23,4 +23,8 @@ public class CLICommand<V extends MIInfo> extends MICommand<V>
|
|||
public CLICommand(IDMContext ctx, String oper) {
|
||||
super(ctx, oper);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean supportsThreadAndFrameOptions() { return false; }
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,19 +43,11 @@ public class MICommand<V extends MIInfo> implements ICommand<V> {
|
|||
/*
|
||||
* Constructors.
|
||||
*/
|
||||
|
||||
/*public DsfMICommand(String operation) {
|
||||
this(operation, empty, empty);
|
||||
}*/
|
||||
|
||||
|
||||
public MICommand(IDMContext ctx, String operation) {
|
||||
this(ctx, operation, empty, empty);
|
||||
}
|
||||
|
||||
/*public DsfMICommand(String operation, String[] options) {
|
||||
this(operation, options, empty);
|
||||
}*/
|
||||
|
||||
public MICommand(IDMContext ctx, String operation, String[] options) {
|
||||
this(ctx, operation, options, empty);
|
||||
}
|
||||
|
|
@ -137,10 +129,27 @@ public class MICommand<V extends MIInfo> implements ICommand<V> {
|
|||
}
|
||||
|
||||
/*
|
||||
* Returns the constructed command.
|
||||
* Returns the constructed command without using the --thread/--frame options.
|
||||
*/
|
||||
public String constructCommand() {
|
||||
return constructCommand(null, -1);
|
||||
}
|
||||
/*
|
||||
* Returns the constructed command potentially using the --thread/--frame options.
|
||||
*/
|
||||
public String constructCommand(String threadId, int frameId) {
|
||||
StringBuffer command = new StringBuffer(getOperation());
|
||||
|
||||
// Add the --thread option
|
||||
if (threadId != null) {
|
||||
command.append(" --thread " + threadId); //$NON-NLS-1$
|
||||
|
||||
// Add the --frame option, but only if we are using the --thread option
|
||||
if (frameId >= 0) {
|
||||
command.append(" --frame " + frameId); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
|
||||
String opt = optionsToString();
|
||||
if (opt.length() > 0) {
|
||||
command.append(' ').append(opt);
|
||||
|
|
@ -225,6 +234,7 @@ public class MICommand<V extends MIInfo> implements ICommand<V> {
|
|||
return false;
|
||||
}
|
||||
|
||||
public boolean supportsThreadAndFrameOptions() { return true; }
|
||||
|
||||
/**
|
||||
* Compare commands based on the MI command string that they generate,
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ import org.eclipse.dd.mi.service.command.output.MIInfo;
|
|||
|
||||
/**
|
||||
*
|
||||
* -exec-continue [--thread <tid>]
|
||||
* -exec-continue [--all]
|
||||
*
|
||||
* Asynchronous command. Resumes the execution of the inferior program
|
||||
* until a breakpoint is encountered, or until the inferior exits.
|
||||
|
|
@ -35,8 +35,4 @@ public class MIExecContinue extends MICommand<MIInfo>
|
|||
setParameters(new String[] { "--all" }); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
|
||||
public MIExecContinue(IExecutionDMContext dmc, int threadId) {
|
||||
super(dmc, "-exec-continue", new String[] { "--thread", Integer.toString(threadId) }); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,12 +14,11 @@
|
|||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIInfo;
|
||||
|
||||
/**
|
||||
*
|
||||
* -exec-interrupt [ --thread <tid> | --all ]
|
||||
* -exec-interrupt [--all]
|
||||
*
|
||||
* Asynchronous command. Interrupts the background execution of the
|
||||
* target. Note how the token associated with the stop message is the one
|
||||
|
|
@ -41,11 +40,4 @@ public class MIExecInterrupt extends MICommand<MIInfo>
|
|||
setParameters(new String[] { "--all" }); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
|
||||
public MIExecInterrupt(IMIExecutionDMContext dmc, boolean setThread) {
|
||||
super(dmc, "-exec-interrupt"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()) }); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,12 +14,11 @@
|
|||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIInfo;
|
||||
|
||||
/**
|
||||
*
|
||||
* -exec-next [--thread <tid>] [count]
|
||||
* -exec-next [count]
|
||||
*
|
||||
* Asynchronous command. Resumes execution of the inferior program,
|
||||
* stopping when the beginning of the next source line is reached.
|
||||
|
|
@ -34,17 +33,4 @@ public class MIExecNext extends MICommand<MIInfo>
|
|||
public MIExecNext(IExecutionDMContext dmc, int count) {
|
||||
super(dmc, "-exec-next", new String[] { Integer.toString(count) }); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
public MIExecNext(IMIExecutionDMContext dmc, boolean setThread) {
|
||||
this(dmc, setThread, 1);
|
||||
}
|
||||
|
||||
public MIExecNext(IMIExecutionDMContext dmc, boolean setThread, int count) {
|
||||
super(dmc, "-exec-next"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()), Integer.toString(count) }); //$NON-NLS-1$
|
||||
} else {
|
||||
setParameters(new String[] { Integer.toString(count) });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -13,12 +13,11 @@
|
|||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIInfo;
|
||||
|
||||
/**
|
||||
*
|
||||
* -exec-next-instruction
|
||||
* -exec-next-instruction [count]
|
||||
*
|
||||
* Asynchronous command. Executes one machine instruction. If the
|
||||
* instruction is a function call continues until the function returns. If
|
||||
|
|
@ -35,17 +34,4 @@ public class MIExecNextInstruction extends MICommand<MIInfo>
|
|||
public MIExecNextInstruction(IExecutionDMContext dmc, int count) {
|
||||
super(dmc, "-exec-next-instruction", new String[] { Integer.toString(count) }); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
public MIExecNextInstruction(IMIExecutionDMContext dmc, boolean setThread) {
|
||||
this(dmc, setThread, 1);
|
||||
}
|
||||
|
||||
public MIExecNextInstruction(IMIExecutionDMContext dmc, boolean setThread, int count) {
|
||||
super(dmc, "-exec-next-instruction"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()), Integer.toString(count) }); //$NON-NLS-1$
|
||||
} else {
|
||||
setParameters(new String[] { Integer.toString(count) });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ import org.eclipse.dd.mi.service.command.output.MIInfo;
|
|||
|
||||
/**
|
||||
*
|
||||
* -exec-return [args]
|
||||
* -exec-return [arg]
|
||||
*
|
||||
* <p>
|
||||
* Makes current function return immediately. Doesn't execute the
|
||||
|
|
|
|||
|
|
@ -14,12 +14,11 @@
|
|||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIInfo;
|
||||
|
||||
/**
|
||||
*
|
||||
* -exec-step [--thread <tid>] [count]
|
||||
* -exec-step [count]
|
||||
*
|
||||
* Asynchronous command. Resumes execution of the inferior program,
|
||||
* stopping when the beginning of the next source line is reached, if the
|
||||
|
|
@ -36,17 +35,4 @@ public class MIExecStep extends MICommand<MIInfo>
|
|||
public MIExecStep(IExecutionDMContext dmc, int count) {
|
||||
super(dmc, "-exec-step", new String[] { Integer.toString(count) }); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
public MIExecStep(IMIExecutionDMContext dmc, boolean setThread) {
|
||||
this(dmc, setThread, 1);
|
||||
}
|
||||
|
||||
public MIExecStep(IMIExecutionDMContext dmc, boolean setThread, int count) {
|
||||
super(dmc, "-exec-step"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()), Integer.toString(count) }); //$NON-NLS-1$
|
||||
} else {
|
||||
setParameters(new String[] { Integer.toString(count) });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,12 +13,11 @@
|
|||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIInfo;
|
||||
|
||||
/**
|
||||
*
|
||||
* -exec-step-instruction [--thread <tid>] [count]
|
||||
* -exec-step-instruction [count]
|
||||
|
||||
* Asynchronous command. Resumes the inferior which executes one
|
||||
* machine instruction. The output, once GDB has stopped, will vary
|
||||
|
|
@ -36,17 +35,4 @@ public class MIExecStepInstruction extends MICommand<MIInfo>
|
|||
public MIExecStepInstruction(IExecutionDMContext dmc, int count) {
|
||||
super(dmc, "-exec-step-instruction", new String[] { Integer.toString(count) }); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
public MIExecStepInstruction(IMIExecutionDMContext dmc, boolean setThread) {
|
||||
this(dmc, setThread, 1);
|
||||
}
|
||||
|
||||
public MIExecStepInstruction(IMIExecutionDMContext dmc, boolean setThread, int count) {
|
||||
super(dmc, "-exec-step-instruction"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()), Integer.toString(count) }); //$NON-NLS-1$
|
||||
} else {
|
||||
setParameters(new String[] { Integer.toString(count) });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,12 +14,11 @@
|
|||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIInfo;
|
||||
|
||||
/**
|
||||
*
|
||||
* -exec-until [--thread <tid>] [ LOCATION ]
|
||||
* -exec-until [ LOCATION ]
|
||||
*
|
||||
* Asynchronous command. Executes the inferior until the LOCATION
|
||||
* specified in the argument is reached. If there is no argument, the
|
||||
|
|
@ -37,20 +36,4 @@ public class MIExecUntil extends MICommand<MIInfo>
|
|||
public MIExecUntil(IExecutionDMContext dmc, String loc) {
|
||||
super(dmc, "-exec-until", new String[] { loc }); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
public MIExecUntil(IMIExecutionDMContext dmc, boolean setThread) {
|
||||
super(dmc, "-exec-until"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()) }); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
|
||||
public MIExecUntil(IMIExecutionDMContext dmc, boolean setThread, String loc) {
|
||||
super(dmc, "-exec-until"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()), loc }); //$NON-NLS-1$
|
||||
} else {
|
||||
setParameters(new String[] { loc });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ import org.eclipse.dd.mi.service.command.output.MIStackInfoDepthInfo;
|
|||
|
||||
/**
|
||||
*
|
||||
* -stack-info-depth [--thread <tid>] [maxDepth]
|
||||
* -stack-info-depth [maxDepth]
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
|
@ -25,28 +25,11 @@ public class MIStackInfoDepth extends MICommand<MIStackInfoDepthInfo>
|
|||
{
|
||||
|
||||
public MIStackInfoDepth(IMIExecutionDMContext ctx) {
|
||||
this(ctx, false);
|
||||
}
|
||||
|
||||
public MIStackInfoDepth(IMIExecutionDMContext ctx, boolean setThread) {
|
||||
super(ctx, "-stack-info-depth"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(ctx.getThreadId()) }); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
|
||||
public MIStackInfoDepth(IMIExecutionDMContext ctx, int maxDepth) {
|
||||
this(ctx, false, maxDepth);
|
||||
}
|
||||
|
||||
public MIStackInfoDepth(IMIExecutionDMContext ctx, boolean setThread, int maxDepth) {
|
||||
super(ctx, "-stack-info-depth"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(ctx.getThreadId()), Integer.toString(maxDepth) }); //$NON-NLS-1$
|
||||
}
|
||||
else {
|
||||
setParameters(new String[] { Integer.toString(maxDepth) });
|
||||
}
|
||||
super(ctx, "-stack-info-depth", new String[]{Integer.toString(maxDepth)}); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ import org.eclipse.dd.mi.service.command.output.MIStackListArgumentsInfo;
|
|||
|
||||
/**
|
||||
*
|
||||
* -stack-list-arguments [--thread <tid>] SHOW-VALUES
|
||||
* -stack-list-arguments SHOW-VALUES
|
||||
* [ LOW-FRAME HIGH-FRAME ]
|
||||
*
|
||||
* Display a list of the arguments for the frames between LOW-FRAME and
|
||||
|
|
@ -35,16 +35,7 @@ import org.eclipse.dd.mi.service.command.output.MIStackListArgumentsInfo;
|
|||
public class MIStackListArguments extends MICommand<MIStackListArgumentsInfo>
|
||||
{
|
||||
public MIStackListArguments(IMIExecutionDMContext execDmc, boolean showValues) {
|
||||
this(execDmc, false, showValues);
|
||||
}
|
||||
|
||||
public MIStackListArguments(IMIExecutionDMContext execDmc, boolean setThread, boolean showValues) {
|
||||
super(execDmc, "-stack-list-arguments"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()), showValues ? "1" : "0" } ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
|
||||
} else {
|
||||
setParameters(new String[] { showValues ? "1" : "0" } ); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
super(execDmc, "-stack-list-arguments", new String[] { showValues ? "1" : "0" }); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
|
||||
}
|
||||
|
||||
public MIStackListArguments(IFrameDMContext frameDmc, boolean showValues) {
|
||||
|
|
@ -52,18 +43,8 @@ public class MIStackListArguments extends MICommand<MIStackListArgumentsInfo>
|
|||
}
|
||||
|
||||
public MIStackListArguments(IMIExecutionDMContext execDmc, boolean showValues, int low, int high) {
|
||||
this(execDmc, false, showValues, low, high);
|
||||
}
|
||||
|
||||
public MIStackListArguments(IMIExecutionDMContext execDmc, boolean setThread, boolean showValues, int low, int high) {
|
||||
super(execDmc, "-stack-list-arguments"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()), //$NON-NLS-1$
|
||||
showValues ? "1" : "0", Integer.toString(low), Integer.toString(high) } ); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
} else {
|
||||
setParameters(new String[] {
|
||||
showValues ? "1" : "0", Integer.toString(low), Integer.toString(high) } ); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
super(execDmc, "-stack-list-arguments", //$NON-NLS-1$
|
||||
new String[] {showValues ? "1" : "0", Integer.toString(low), Integer.toString(high)}); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -54,27 +54,11 @@ import org.eclipse.dd.mi.service.command.output.MIStackListFramesInfo;
|
|||
public class MIStackListFrames extends MICommand<MIStackListFramesInfo>
|
||||
{
|
||||
public MIStackListFrames(IMIExecutionDMContext execDmc) {
|
||||
this(execDmc, false);
|
||||
}
|
||||
|
||||
public MIStackListFrames(IMIExecutionDMContext execDmc, boolean setThread) {
|
||||
super(execDmc, "-stack-list-frames"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()) } ); //$NON-NLS-1$
|
||||
}
|
||||
}
|
||||
|
||||
public MIStackListFrames(IMIExecutionDMContext execDmc, int low, int high) {
|
||||
this(execDmc, false, low, high);
|
||||
}
|
||||
|
||||
public MIStackListFrames(IMIExecutionDMContext execDmc, boolean setThread, int low, int high) {
|
||||
super(execDmc, "-stack-list-frames"); //$NON-NLS-1$
|
||||
if (setThread) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()), Integer.toString(low), Integer.toString(high) } ); //$NON-NLS-1$
|
||||
} else {
|
||||
setParameters(new String[] { Integer.toString(low), Integer.toString(high) } );
|
||||
}
|
||||
super(execDmc, "-stack-list-frames", new String[] { Integer.toString(low), Integer.toString(high) }); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -13,9 +13,7 @@
|
|||
|
||||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.datamodel.DMContexts;
|
||||
import org.eclipse.dd.dsf.debug.service.IStack.IFrameDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIOutput;
|
||||
import org.eclipse.dd.mi.service.command.output.MIStackListLocalsInfo;
|
||||
|
||||
|
|
@ -32,19 +30,9 @@ public class MIStackListLocals extends MICommand<MIStackListLocalsInfo>
|
|||
{
|
||||
|
||||
public MIStackListLocals(IFrameDMContext frameCtx, boolean printValues) {
|
||||
this(frameCtx, false, printValues);
|
||||
super(frameCtx, "-stack-list-locals", new String[] { printValues ? "1" : "0" } ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
|
||||
}
|
||||
|
||||
public MIStackListLocals(IFrameDMContext frameCtx, boolean setThread, boolean printValues) {
|
||||
super(frameCtx, "-stack-list-locals"); //$NON-NLS-1$
|
||||
IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(frameCtx, IMIExecutionDMContext.class);
|
||||
if (setThread && execDmc != null) {
|
||||
setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()), printValues ? "1" : "0" } ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
|
||||
} else {
|
||||
setParameters(new String[] { printValues ? "1" : "0" } ); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public MIStackListLocalsInfo getResult(MIOutput out) {
|
||||
return new MIStackListLocalsInfo(out);
|
||||
|
|
|
|||
|
|
@ -28,8 +28,4 @@ public class MIStackSelectFrame extends MICommand<MIInfo> {
|
|||
public MIStackSelectFrame(IDMContext ctx, int frameNum) {
|
||||
super(ctx, "-stack-select-frame", new String[]{Integer.toString(frameNum)}, new String[0]); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
public MIStackSelectFrame(IDMContext ctx, int threadNum, int frameNum) {
|
||||
super(ctx, "-stack-select-frame", new String[]{ "--thread", Integer.toString(threadNum), Integer.toString(frameNum) }); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,11 +19,11 @@ import org.eclipse.dd.mi.service.command.output.MIInfo;
|
|||
public class MITargetSelect extends MICommand<MIInfo> {
|
||||
|
||||
public MITargetSelect(IDMContext ctx, String host, String port) {
|
||||
super(ctx, "-target-select extended-remote " + host + ":" + port); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
super(ctx, "-target-select extended-remote", new String[] {host + ":" + port}); //$NON-NLS-1$ //$NON-NLS-2$
|
||||
}
|
||||
|
||||
public MITargetSelect(IDMContext ctx, String serialDevice) {
|
||||
super(ctx, "-target-select extended-remote " + serialDevice); //$NON-NLS-1$
|
||||
super(ctx, "-target-select extended-remote", new String[] {serialDevice}); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@
|
|||
package org.eclipse.dd.mi.service.command.commands;
|
||||
|
||||
import org.eclipse.dd.dsf.datamodel.IDMContext;
|
||||
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
|
||||
import org.eclipse.dd.mi.service.command.output.MIInfo;
|
||||
|
||||
|
||||
|
|
@ -28,12 +27,12 @@ import org.eclipse.dd.mi.service.command.output.MIInfo;
|
|||
|
||||
public class MIThreadSelect extends MICommand<MIInfo>
|
||||
{
|
||||
@Deprecated
|
||||
public MIThreadSelect(IDMContext ctx, int threadNum) {
|
||||
super(ctx, "-thread-select", new String[]{Integer.toString(threadNum)}); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
public MIThreadSelect(IMIExecutionDMContext ctx) {
|
||||
super(ctx, "-thread-select", new String[]{Integer.toString(ctx.getThreadId())}); //$NON-NLS-1$
|
||||
|
||||
public MIThreadSelect(IDMContext ctx, String threadNum) {
|
||||
super(ctx, "-thread-select", new String[]{threadNum}); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,6 +27,9 @@ public class RawCommand extends MICommand<MIInfo> {
|
|||
fRaw = operation;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean supportsThreadAndFrameOptions() { return false; }
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.eclipse.cdt.debug.mi.core.command.Command#getMIOutput()
|
||||
*/
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue