Attachment #107674 for bug #237556

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;
import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControlDMContext;
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
import org.eclipse.dd.mi.service.IMIRunControl;
import org.eclipse.dd.mi.service.MIRunControl;
import org.eclipse.dd.mi.service.command.commands.CLIInfoThreads;
import org.eclipse.dd.mi.service.command.events.MIEvent;
import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;
import org.eclipse.dd.mi.service.command.output.CLIInfoThreadsInfo;
public class GDBRunControl extends MIRunControl {

public class GDBRunControl extends MIRunControl implements IGDBRunControl {
     * Implement a custom execution data for threads in order to provide additional 
     * information.  This object can be made separate from IExecutionDMData after
     * the deprecated method: IDMService.getModelData() is no longer used.  
     */
    public static class GDBThreadData {
        private final String fId;
        private final String fName;

        GDBThreadData(String id, String name) {
            fId = id;
            fName = name;
        }
        
        public String getName() {
            return fName; 
        }
        public String getId() { return fId; } 

        public boolean isDebuggerAttached() { return true; }
    }

    /**
     * Implement a custom execution data the process in order to provide additional 
     * information.  This object can be made separate from IExecutionDMData after
     * the deprecated method: IDMService.getModelData() is no longer used.  
     */
    public static class GDBProcessData {
        private final String fName;
        
        GDBProcessData(String name) {
            fName = name;
        }
        
        public String getName() {
            return fName;
        }
    }
    
    private GDBControl fGdb;
    
	// Record list of execution contexts

    private void doInitialize(final RequestMonitor requestMonitor) {
    	
        fGdb = getServicesTracker().getService(GDBControl.class);
        register(new String[]{IRunControl.class.getName(), IMIRunControl.class.getName(), IGDBRunControl.class.getName()}, new Hashtable<String,String>());

        requestMonitor.done();
    }

	}

    private GDBThreadData createThreadInfo(IMIExecutionDMContext dmc, CLIInfoThreadsInfo info){
        for (CLIInfoThreadsInfo.CLIThreadInfo thread : info.getThreadInfo()) {
            if(Integer.parseInt(thread.getId()) == dmc.getThreadId()){
                //fMapThreadIds.put(thread.getId(), String.valueOf(dmc.getId()));
                return new GDBThreadData(thread.getOsId(), thread.getName());       

Lines 37-42 Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/launching/GdbLaunchDelegate.java (-1 / +22 lines)
37	import org.eclipse.dd.gdb.internal.GdbPlugin;	37	import org.eclipse.dd.gdb.internal.GdbPlugin;
38	import org.eclipse.dd.gdb.internal.provisional.IGDBLaunchConfigurationConstants;	38	import org.eclipse.dd.gdb.internal.provisional.IGDBLaunchConfigurationConstants;
39	import org.eclipse.dd.gdb.internal.provisional.service.GdbDebugServicesFactory;	39	import org.eclipse.dd.gdb.internal.provisional.service.GdbDebugServicesFactory;
		40	import org.eclipse.dd.gdb.internal.provisional.service.GdbDebugServicesFactoryNS;
40	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl.SessionType;	41	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl.SessionType;
41	import org.eclipse.debug.core.DebugException;	42	import org.eclipse.debug.core.DebugException;
42	import org.eclipse.debug.core.ILaunch;	43	import org.eclipse.debug.core.ILaunch;
Lines 56-62 Link Here
56	{	57	{
57	public final static String GDB_DEBUG_MODEL_ID = "org.eclipse.dd.gdb"; //$NON-NLS-1$	58	public final static String GDB_DEBUG_MODEL_ID = "org.eclipse.dd.gdb"; //$NON-NLS-1$
58		59
59	public void launch( ILaunchConfiguration config, String mode, ILaunch launch, IProgressMonitor monitor ) throws CoreException {	60	private boolean isNonStopSession = false;
		61
		62	public void launch( ILaunchConfiguration config, String mode, ILaunch launch, IProgressMonitor monitor ) throws CoreException {
60	if ( monitor == null ) {	63	if ( monitor == null ) {
61	monitor = new NullProgressMonitor();	64	monitor = new NullProgressMonitor();
62	}	65	}
Lines 167-172 Link Here
167	return SessionType.LOCAL;	170	return SessionType.LOCAL;
168	}	171	}
169		172
		173	private boolean isNonStopSession(ILaunchConfiguration config) {
		174	try {
		175	boolean nonStopMode = config.getAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_NON_STOP,
		176	IGDBLaunchConfigurationConstants.DEBUGGER_NON_STOP_DEFAULT);
		177	return nonStopMode;
		178	} catch (CoreException e) {
		179	}
		180	return false;
		181	}
		182
170	private boolean getIsAttach(ILaunchConfiguration config) {	183	private boolean getIsAttach(ILaunchConfiguration config) {
171	try {	184	try {
172	String debugMode = config.getAttribute( ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_START_MODE, ICDTLaunchConfigurationConstants.DEBUGGER_MODE_RUN );	185	String debugMode = config.getAttribute( ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_START_MODE, ICDTLaunchConfigurationConstants.DEBUGGER_MODE_RUN );
Lines 202-207 Link Here
202	// the adapters will be created for the whole session, including	215	// the adapters will be created for the whole session, including
203	// the source lookup adapter.	216	// the source lookup adapter.
204		217
		218	isNonStopSession = isNonStopSession(configuration);
		219
205	GdbLaunch launch = new GdbLaunch(configuration, mode, null);	220	GdbLaunch launch = new GdbLaunch(configuration, mode, null);
206	launch.initialize();	221	launch.initialize();
207	launch.setSourceLocator(getSourceLocator(configuration, launch.getSession()));	222	launch.setSourceLocator(getSourceLocator(configuration, launch.getSession()));
Lines 314-319 Link Here
314	}	329	}
315		330
316	private IDsfDebugServicesFactory newServiceFactory(String version) {	331	private IDsfDebugServicesFactory newServiceFactory(String version) {
		332
		333	// TODO: Fix version number once non-stop GDB is delivered
		334	if (isNonStopSession && version.startsWith("6.8.50.20080327")) { //$NON-NLS-1$
		335	return new GdbDebugServicesFactoryNS(version);
		336	}
		337
317	if (version.startsWith("6.6") \|\| //$NON-NLS-1$	338	if (version.startsWith("6.6") \|\| //$NON-NLS-1$
318	version.startsWith("6.7") \|\| //$NON-NLS-1$	339	version.startsWith("6.7") \|\| //$NON-NLS-1$
319	version.startsWith("6.8")) { //$NON-NLS-1$	340	version.startsWith("6.8")) { //$NON-NLS-1$

Lines 49-54 Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/IGDBLaunchConfigurationConstants.java (+11 lines)
49	public static final String ATTR_GDB_INIT = GdbPlugin.PLUGIN_ID + ".GDB_INIT"; //$NON-NLS-1$	49	public static final String ATTR_GDB_INIT = GdbPlugin.PLUGIN_ID + ".GDB_INIT"; //$NON-NLS-1$
50		50
51	/**	51	/**
		52	* Launch configuration attribute key. Boolean value to set the non-stop mode
		53	* Debuger/gdb/MI property.
		54	*/
		55	public static final String ATTR_DEBUGGER_NON_STOP = GdbPlugin.PLUGIN_ID + ".NON_STOP"; //$NON-NLS-1$
		56
		57	/**
52	* Launch configuration attribute key. Boolean value to set the 'automatically load shared library symbols' flag of the debugger.	58	* Launch configuration attribute key. Boolean value to set the 'automatically load shared library symbols' flag of the debugger.
53	*/	59	*/
54	public static final String ATTR_DEBUGGER_AUTO_SOLIB = GdbPlugin.PLUGIN_ID + ".AUTO_SOLIB"; //$NON-NLS-1$	60	public static final String ATTR_DEBUGGER_AUTO_SOLIB = GdbPlugin.PLUGIN_ID + ".AUTO_SOLIB"; //$NON-NLS-1$
Lines 79-84 Link Here
79	public static final String DEBUGGER_GDB_INIT_DEFAULT = ".gdbinit"; //$NON-NLS-1$	85	public static final String DEBUGGER_GDB_INIT_DEFAULT = ".gdbinit"; //$NON-NLS-1$
80		86
81	/**	87	/**
		88	* Launch configuration attribute value. The key is ATTR_DEBUGGER_NON_STOP.
		89	*/
		90	public static final boolean DEBUGGER_NON_STOP_DEFAULT = false;
		91
		92	/**
82	* Launch configuration attribute value. The key is ATTR_DEBUGGER_AUTO_SOLIB.	93	* Launch configuration attribute value. The key is ATTR_DEBUGGER_AUTO_SOLIB.
83	*/	94	*/
84	public static final boolean DEBUGGER_AUTO_SOLIB_DEFAULT = true;	95	public static final boolean DEBUGGER_AUTO_SOLIB_DEFAULT = true;




/*******************************************************************************
 * 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 additional functionality
 *******************************************************************************/
package org.eclipse.dd.gdb.internal.provisional.service;

import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControlDMContext;
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
import org.eclipse.dd.mi.service.IMIRunControl;

/**
 * This interface provides access to controlling and monitoring the execution 
 * state of a process being debugged.  This interface does not actually 
 * provide methods for creating or destroying execution contexts, it doesn't
 * even have methods for getting labels.  That's because it is expected that
 * higher level services, ones that deal with processes, kernels, or target 
 * features will provide that functionality. 
 */
public interface IGDBRunControl extends IMIRunControl
{
	/**
     * Implement a custom execution data for threads in order to provide additional 
     * information.  This object can be made separate from IExecutionDMData after
     * the deprecated method: IDMService.getModelData() is no longer used.  
     */
    public static class GDBThreadData {
        private final String fId;
        private final String fName;

        GDBThreadData(String id, String name) {
            fId = id;
            fName = name;
        }
        
        public String getName() {
            return fName; 
        }
        public String getId() { return fId; } 

        public boolean isDebuggerAttached() { return true; }
    }

    /**
     * Implement a custom execution data the process in order to provide additional 
     * information.  This object can be made separate from IExecutionDMData after
     * the deprecated method: IDMService.getModelData() is no longer used.  
     */
    public static class GDBProcessData {
        private final String fName;
        
        GDBProcessData(String name) {
            fName = name;
        }
        
        public String getName() {
            return fName;
        }
    }

	public void getProcessData(GDBControlDMContext gdbDmc, DataRequestMonitor<GDBProcessData> rm);
    public void getThreadData(final IMIExecutionDMContext execDmc, final DataRequestMonitor<GDBThreadData> dataRequestMonitor);
}




/*******************************************************************************
 * Copyright (c) 2008 Ericsson 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:
 *     Ericsson - initial API and implementation
 *******************************************************************************/
package org.eclipse.dd.gdb.internal.provisional.service;

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.MIStackNS;

public class GdbDebugServicesFactoryNS extends GdbDebugServicesFactory {

	public GdbDebugServicesFactoryNS(String version) {
		super(version);
	}
		
	@Override
	protected IStack createStackService(DsfSession session) {
		return new MIStackNS(session);
	}
	
	@Override
	protected IRunControl createRunControlService(DsfSession session) {
		return new GDBRunControlNS(session);
	}
}




/*******************************************************************************
 * 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 AB		  - Modified for additional functionality	
 *******************************************************************************/

package org.eclipse.dd.gdb.internal.provisional.service;


import java.util.Hashtable;

import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
import org.eclipse.dd.dsf.concurrent.RequestMonitor;
import org.eclipse.dd.dsf.datamodel.DMContexts;
import org.eclipse.dd.dsf.debug.service.IRunControl;
import org.eclipse.dd.dsf.service.DsfSession;
import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;
import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControlDMContext;
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
import org.eclipse.dd.mi.service.IMIRunControl;
import org.eclipse.dd.mi.service.MIRunControlNS;
import org.eclipse.dd.mi.service.command.commands.MIThreadInfo;
import org.eclipse.dd.mi.service.command.output.MIThreadInfoInfo;

public class GDBRunControlNS extends MIRunControlNS implements IGDBRunControl 
{
    private GDBControl fGdb;
    
    public GDBRunControlNS(DsfSession session) {
        super(session);
    }
    
    @Override
    public void initialize(final RequestMonitor requestMonitor) {
        super.initialize(
            new RequestMonitor(getExecutor(), requestMonitor) { 
                @Override
                public void handleSuccess() {
                    doInitialize(requestMonitor);
                }});
    }

    private void doInitialize(final RequestMonitor requestMonitor) {

		fGdb = getServicesTracker().getService(GDBControl.class);
        register(new String[]{IRunControl.class.getName(), IMIRunControl.class.getName(), IGDBRunControl.class.getName()}, new Hashtable<String,String>());

        requestMonitor.done();
    }

    @Override
    public void shutdown(final RequestMonitor requestMonitor) {
        unregister();
        super.shutdown(requestMonitor);
    }

	public void getProcessData(GDBControlDMContext gdbDmc, DataRequestMonitor<GDBProcessData> rm) {
        rm.setData( new GDBProcessData(fGdb.getExecutablePath().lastSegment()) );
        rm.done();
	}
	
	public void getThreadData(final IMIExecutionDMContext execDmc, final DataRequestMonitor<GDBThreadData> rm) {
        IContainerDMContext containerDmc = DMContexts.getAncestorOfType(execDmc, IContainerDMContext.class);
        assert containerDmc != null;
        getConnection().queueCommand(new MIThreadInfo(containerDmc),
                new DataRequestMonitor<MIThreadInfoInfo>(getExecutor(), rm) {
                    @Override
                    protected void handleSuccess() {
                        rm.setData(createThreadInfo(execDmc, getData()));
                        rm.done();
                    }
                });
	}

	private GDBThreadData createThreadInfo(IMIExecutionDMContext dmc, MIThreadInfoInfo info){
		for (MIThreadInfoInfo.ThreadInfo thread : info.getThreadInfoList()) {
			if (Integer.parseInt(thread.getGdbId()) == dmc.getThreadId()){
				return new GDBThreadData(thread.getOsId(), "");        //$NON-NLS-1$
			}
		}
		return  new GDBThreadData("", "");  //$NON-NLS-1$ //$NON-NLS-2$
	}

}

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MIBreakpointHitEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIConst;	19	import org.eclipse.dd.mi.service.command.output.MIConst;
20	import org.eclipse.dd.mi.service.command.output.MIFrame;	20	import org.eclipse.dd.mi.service.command.output.MIFrame;
21	import org.eclipse.dd.mi.service.command.output.MIResult;	21	import org.eclipse.dd.mi.service.command.output.MIResult;
Lines 40-46 Link Here
40	}	40	}
41		41
42	public static MIBreakpointHitEvent parse(	42	public static MIBreakpointHitEvent parse(
43	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	43	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
44	{	44	{
45	int bkptno = -1;	45	int bkptno = -1;
46		46

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MILocationReachedEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIFrame;	19	import org.eclipse.dd.mi.service.command.output.MIFrame;
20	import org.eclipse.dd.mi.service.command.output.MIResult;	20	import org.eclipse.dd.mi.service.command.output.MIResult;
21		21
Lines 30-36 Link Here
30	}	30	}
31		31
32	public static MILocationReachedEvent parse(	32	public static MILocationReachedEvent parse(
33	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	33	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
34	{	34	{
35	MIStoppedEvent stoppedEvent = MIStoppedEvent.parse(runControl, containerDmc, token, results);	35	MIStoppedEvent stoppedEvent = MIStoppedEvent.parse(runControl, containerDmc, token, results);
36	return new MILocationReachedEvent(stoppedEvent.getDMContext(), token, results, stoppedEvent.getFrame());	36	return new MILocationReachedEvent(stoppedEvent.getDMContext(), token, results, stoppedEvent.getFrame());

Lines 14-19 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MIThreadCreatedEvent.java (+24 lines)
14		14
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
		17	import org.eclipse.dd.mi.service.command.output.MIConst;
		18	import org.eclipse.dd.mi.service.command.output.MIResult;
		19	import org.eclipse.dd.mi.service.command.output.MIValue;
17		20
18		21
19	/**	22	/**
Lines 37-40 Link Here
37	public int getId() {	40	public int getId() {
38	return tid;	41	return tid;
39	}	42	}
		43
		44	public static MIThreadCreatedEvent parse(IContainerDMContext ctx, int token, MIResult[] results)
		45	{
		46	for (int i = 0; i < results.length; i++) {
		47	String var = results[i].getVariable();
		48	MIValue val = results[i].getMIValue();
		49	if (var.equals("id")) { //$NON-NLS-1$
		50	if (val instanceof MIConst) {
		51	try {
		52	int thread = Integer.parseInt(((MIConst) val).getString());
		53	return new MIThreadCreatedEvent(ctx, token, thread);
		54	}
		55	catch (NumberFormatException e) {
		56	return null;
		57	}
		58	}
		59	}
		60	}
		61
		62	return null;
		63	}
40	}	64	}

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MISharedLibEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIFrame;	19	import org.eclipse.dd.mi.service.command.output.MIFrame;
20	import org.eclipse.dd.mi.service.command.output.MIResult;	20	import org.eclipse.dd.mi.service.command.output.MIResult;
21		21
Lines 30-36 Link Here
30	}	30	}
31		31
32	public static MIStoppedEvent parse(	32	public static MIStoppedEvent parse(
33	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	33	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
34	{	34	{
35	MIStoppedEvent stoppedEvent = MIStoppedEvent.parse(runControl, containerDmc, token, results);	35	MIStoppedEvent stoppedEvent = MIStoppedEvent.parse(runControl, containerDmc, token, results);
36	return new MISharedLibEvent(stoppedEvent.getDMContext(), token, results, stoppedEvent.getFrame());	36	return new MISharedLibEvent(stoppedEvent.getDMContext(), token, results, stoppedEvent.getFrame());

Lines 14-19 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MIThreadExitEvent.java (+24 lines)
14		14
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
		17	import org.eclipse.dd.mi.service.command.output.MIConst;
		18	import org.eclipse.dd.mi.service.command.output.MIResult;
		19	import org.eclipse.dd.mi.service.command.output.MIValue;
17		20
18		21
19	/**	22	/**
Lines 37-40 Link Here
37	public int getId() {	40	public int getId() {
38	return tid;	41	return tid;
39	}	42	}
		43
		44	public static MIThreadExitEvent parse(IContainerDMContext ctx, int token, MIResult[] results)
		45	{
		46	for (int i = 0; i < results.length; i++) {
		47	String var = results[i].getVariable();
		48	MIValue val = results[i].getMIValue();
		49	if (var.equals("id")) { //$NON-NLS-1$
		50	if (val instanceof MIConst) {
		51	try {
		52	int thread = Integer.parseInt(((MIConst) val).getString());
		53	return new MIThreadExitEvent(ctx, token, thread);
		54	}
		55	catch (NumberFormatException e) {
		56	return null;
		57	}
		58	}
		59	}
		60	}
		61
		62	return null;
		63	}
40	}	64	}

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MISteppingRangeEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIFrame;	19	import org.eclipse.dd.mi.service.command.output.MIFrame;
20	import org.eclipse.dd.mi.service.command.output.MIResult;	20	import org.eclipse.dd.mi.service.command.output.MIResult;
21		21
Lines 31-37 Link Here
31	}	31	}
32		32
33	public static MISteppingRangeEvent parse(	33	public static MISteppingRangeEvent parse(
34	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	34	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
35	{	35	{
36	MIStoppedEvent stoppedEvent = MIStoppedEvent.parse(runControl, containerDmc, token, results);	36	MIStoppedEvent stoppedEvent = MIStoppedEvent.parse(runControl, containerDmc, token, results);
37	return new MISteppingRangeEvent(stoppedEvent.getDMContext(), token, results, stoppedEvent.getFrame());	37	return new MISteppingRangeEvent(stoppedEvent.getDMContext(), token, results, stoppedEvent.getFrame());

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MISignalEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIConst;	19	import org.eclipse.dd.mi.service.command.output.MIConst;
20	import org.eclipse.dd.mi.service.command.output.MIFrame;	20	import org.eclipse.dd.mi.service.command.output.MIFrame;
21	import org.eclipse.dd.mi.service.command.output.MIResult;	21	import org.eclipse.dd.mi.service.command.output.MIResult;
Lines 49-55 Link Here
49	}	49	}
50		50
51	public static MISignalEvent parse(	51	public static MISignalEvent parse(
52	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	52	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
53	{	53	{
54	String sigName = ""; //$NON-NLS-1$	54	String sigName = ""; //$NON-NLS-1$
55	String sigMeaning = ""; //$NON-NLS-1$	55	String sigMeaning = ""; //$NON-NLS-1$

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MIWatchpointTriggerEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIConst;	19	import org.eclipse.dd.mi.service.command.output.MIConst;
20	import org.eclipse.dd.mi.service.command.output.MIFrame;	20	import org.eclipse.dd.mi.service.command.output.MIFrame;
21	import org.eclipse.dd.mi.service.command.output.MIResult;	21	import org.eclipse.dd.mi.service.command.output.MIResult;
Lines 62-68 Link Here
62	}	62	}
63		63
64	public static MIWatchpointTriggerEvent parse(	64	public static MIWatchpointTriggerEvent parse(
65	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	65	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
66	{	66	{
67	int number = 0;	67	int number = 0;
68	String exp = ""; //$NON-NLS-1$	68	String exp = ""; //$NON-NLS-1$

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MIStoppedEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIConst;	19	import org.eclipse.dd.mi.service.command.output.MIConst;
20	import org.eclipse.dd.mi.service.command.output.MIFrame;	20	import org.eclipse.dd.mi.service.command.output.MIFrame;
21	import org.eclipse.dd.mi.service.command.output.MIResult;	21	import org.eclipse.dd.mi.service.command.output.MIResult;
Lines 41-47 Link Here
41	}	41	}
42		42
43	public static MIStoppedEvent parse(	43	public static MIStoppedEvent parse(
44	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	44	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
45	{	45	{
46	int threadId = -1;	46	int threadId = -1;
47	MIFrame frame = null;	47	MIFrame frame = null;

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MIFunctionFinishedEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIConst;	19	import org.eclipse.dd.mi.service.command.output.MIConst;
20	import org.eclipse.dd.mi.service.command.output.MIFrame;	20	import org.eclipse.dd.mi.service.command.output.MIFrame;
21	import org.eclipse.dd.mi.service.command.output.MIResult;	21	import org.eclipse.dd.mi.service.command.output.MIResult;
Lines 54-60 Link Here
54	}	54	}
55		55
56	public static MIFunctionFinishedEvent parse(	56	public static MIFunctionFinishedEvent parse(
57	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	57	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
58	{	58	{
59	String gdbResult = ""; //$NON-NLS-1$	59	String gdbResult = ""; //$NON-NLS-1$
60	String returnValue = ""; //$NON-NLS-1$	60	String returnValue = ""; //$NON-NLS-1$

Lines 15-21 Link Here

(-)src/org/eclipse/dd/mi/service/command/events/MIWatchpointScopeEvent.java (-2 / +2 lines)
15	import org.eclipse.dd.dsf.concurrent.Immutable;	15	import org.eclipse.dd.dsf.concurrent.Immutable;
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	17	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
18	import org.eclipse.dd.mi.service.MIRunControl;	18	import org.eclipse.dd.mi.service.IMIRunControl;
19	import org.eclipse.dd.mi.service.command.output.MIConst;	19	import org.eclipse.dd.mi.service.command.output.MIConst;
20	import org.eclipse.dd.mi.service.command.output.MIFrame;	20	import org.eclipse.dd.mi.service.command.output.MIFrame;
21	import org.eclipse.dd.mi.service.command.output.MIResult;	21	import org.eclipse.dd.mi.service.command.output.MIResult;
Lines 42-48 Link Here
42	}	42	}
43		43
44	public static MIWatchpointScopeEvent parse(	44	public static MIWatchpointScopeEvent parse(
45	MIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)	45	IMIRunControl runControl, IContainerDMContext containerDmc, int token, MIResult[] results)
46	{	46	{
47	int number = 0;	47	int number = 0;
48	for (int i = 0; i < results.length; i++) {	48	for (int i = 0; i < results.length; i++) {

Lines 53-59 Link Here

(-)src/org/eclipse/dd/mi/service/command/commands/MIVarCreate.java (-1 / +1 lines)
53	this(dmc, "-", "*", expression); //$NON-NLS-1$ //$NON-NLS-2$	53	this(dmc, "-", "*", expression); //$NON-NLS-1$ //$NON-NLS-2$
54	}	54	}
55		55
56	public MIVarCreate(IExpressionDMContext dmc,String name, String expression) {	56	public MIVarCreate(IExpressionDMContext dmc, String name, String expression) {
57	this(dmc, name, "*", expression); //$NON-NLS-1$	57	this(dmc, name, "*", expression); //$NON-NLS-1$
58	}	58	}
59		59




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]
 *
 *   Asynchronous command.  Resumes execution of the inferior program,
 * stopping when the beginning of the next source line is reached, if the

public class MIExecStep extends MICommand<MIInfo> 
{
    public MIExecStep(IExecutionDMContext dmc) {
        this(dmc, 1);
    }

    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) });
        }
    }
}




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 ]
 *
 *  Asynchronous command.  Interrupts the background execution of the
 *  target.  Note how the token associated with the stop message is the one

public class MIExecInterrupt extends MICommand<MIInfo> 
{
    public MIExecInterrupt(IExecutionDMContext dmc) {
        this(dmc, false);
    }

    public MIExecInterrupt(IExecutionDMContext dmc, boolean allThreads) {
        super(dmc, "-exec-interrupt"); //$NON-NLS-1$
        if (allThreads) {
        	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$
        }
    }
}




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;

/**

public class MIExecNextInstruction extends MICommand<MIInfo> 
{
    public MIExecNextInstruction(IExecutionDMContext dmc) {
        this(dmc, 1);
    }

    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) });
        }
    }
}




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]

 *  Asynchronous command.  Resumes the inferior which executes one
 * machine instruction.  The output, once GDB has stopped, will vary

public class MIExecStepInstruction extends MICommand<MIInfo> 
{
    public MIExecStepInstruction(IExecutionDMContext dmc) {
        this(dmc, 1);
    }

    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) });
        }
    }
}

Lines 17-23 Link Here

(-)src/org/eclipse/dd/mi/service/command/commands/MIExecReturn.java (-2 / +1 lines)
17		17
18	/**	18	/**
19	*	19	*
20	* <code>-exec-return</code>	20	* -exec-return [args]
21	*	21	*
22	* <p>	22	* <p>
23	* Makes current function return immediately. Doesn't execute the	23	* Makes current function return immediately. Doesn't execute the
Lines 38-42 Link Here
38	public MIExecReturn(IFrameDMContext dmc, String arg) {	38	public MIExecReturn(IFrameDMContext dmc, String arg) {
39	super(dmc, "-exec-return", new String[] { arg }); //$NON-NLS-1$	39	super(dmc, "-exec-return", new String[] { arg }); //$NON-NLS-1$
40	}	40	}
41
42	}	41	}




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 ]
 *
 *  Asynchronous command.  Executes the inferior until the LOCATION
 * specified in the argument is reached.  If there is no argument, the

    }

    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 });
        }
    }
}





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;


{
	
    public MIStackListLocals(IFrameDMContext frameCtx, boolean printValues) {
        this(frameCtx, false, printValues);
    }

    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




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]
 *
 *  Asynchronous command.  Resumes execution of the inferior program,
 *  stopping when the beginning of the next source line is reached.

 */
public class MIExecNext extends MICommand<MIInfo> 
{
	public MIExecNext(IExecutionDMContext dmc) {
	    this(dmc, 1);
	}

	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) });
	    }
	}
}

Lines 17-23 Link Here

(-)src/org/eclipse/dd/mi/service/command/commands/MIStackInfoDepth.java (-2 / +19 lines)
17		17
18	/**	18	/**
19	*	19	*
20	* -stack-info-depth [maxDepth]	20	* -stack-info-depth [--thread <tid>] [maxDepth]
21	*	21	*
22	*	22	*
23	*/	23	*/
Lines 25-37 Link Here
25	{	25	{
26		26
27	public MIStackInfoDepth(IMIExecutionDMContext ctx) {	27	public MIStackInfoDepth(IMIExecutionDMContext ctx) {
		28	this(ctx, false);
		29	}
		30
		31	public MIStackInfoDepth(IMIExecutionDMContext ctx, boolean setThread) {
28	super(ctx, "-stack-info-depth"); //$NON-NLS-1$	32	super(ctx, "-stack-info-depth"); //$NON-NLS-1$
		33	if (setThread) {
		34	setParameters(new String[] { "--thread", Integer.toString(ctx.getThreadId()) }); //$NON-NLS-1$
		35	}
29	}	36	}
30		37
31	public MIStackInfoDepth(IMIExecutionDMContext ctx, int maxDepth) {	38	public MIStackInfoDepth(IMIExecutionDMContext ctx, int maxDepth) {
32	super(ctx, "-stack-info-depth", new String[]{Integer.toString(maxDepth)}); //$NON-NLS-1$	39	this(ctx, false, maxDepth);
33	}	40	}
34		41
		42	public MIStackInfoDepth(IMIExecutionDMContext ctx, boolean setThread, int maxDepth) {
		43	super(ctx, "-stack-info-depth"); //$NON-NLS-1$
		44	if (setThread) {
		45	setParameters(new String[] { "--thread", Integer.toString(ctx.getThreadId()), Integer.toString(maxDepth) }); //$NON-NLS-1$
		46	}
		47	else {
		48	setParameters(new String[] { Integer.toString(maxDepth) });
		49	}
		50	}
		51
35	@Override	52	@Override
36	public MIStackInfoDepthInfo getResult(MIOutput out) {	53	public MIStackInfoDepthInfo getResult(MIOutput out) {
37	return new MIStackInfoDepthInfo(out);	54	return new MIStackInfoDepthInfo(out);

Lines 15-22 Link Here

(-)src/org/eclipse/dd/mi/service/command/commands/MIStackSelectFrame.java (-2 lines)
15	import org.eclipse.dd.dsf.datamodel.IDMContext;	15	import org.eclipse.dd.dsf.datamodel.IDMContext;
16	import org.eclipse.dd.mi.service.command.output.MIInfo;	16	import org.eclipse.dd.mi.service.command.output.MIInfo;
17		17
18
19
20	/**	18	/**
21	*	19	*
22	* -stack-select-frame FRAMENUM	20	* -stack-select-frame FRAMENUM





/**
 * 
 *    -stack-list-arguments [--thread <tid>] SHOW-VALUES
 *        [ LOW-FRAME HIGH-FRAME ]
 *
 *  Display a list of the arguments for the frames between LOW-FRAME and

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$
        }
    }

    public MIStackListArguments(IFrameDMContext frameDmc, boolean showValues) {
        super(frameDmc, "-stack-list-arguments", new String[] { showValues ? "1" : "0" }); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        if (showValues) {
            setParameters(new String[]{"1"}); //$NON-NLS-1$
        } else {
            setParameters(new String[]{"0"}); //$NON-NLS-1$
        }
    }
    
    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$
        }
        params[1] = Integer.toString(low);
        params[2] = Integer.toString(high);
        setParameters(params);
    }
    
    @Override




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-continue [--thread <tid>]
 * 
 *   Asynchronous command.  Resumes the execution of the inferior program
 *   until a breakpoint is encountered, or until the inferior exits.

public class MIExecContinue extends MICommand<MIInfo> 
{
    public MIExecContinue(IExecutionDMContext dmc) {
        this(dmc, false);
    }

    public MIExecContinue(IExecutionDMContext dmc, boolean allThreads) {
        super(dmc, "-exec-continue"); //$NON-NLS-1$
        if (allThreads) {
        	setParameters(new String[] { "--all" }); //$NON-NLS-1$
        }
    }

    public MIExecContinue(IMIExecutionDMContext dmc, boolean setThread) {
        super(dmc, "-exec-continue"); //$NON-NLS-1$
        if (setThread) {
        	setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()) }); //$NON-NLS-1$
        }
    }
}

Lines 54-65 Link Here

(-)src/org/eclipse/dd/mi/service/command/commands/MIStackListFrames.java (-2 / +17 lines)
54	public class MIStackListFrames extends MICommand<MIStackListFramesInfo>	54	public class MIStackListFrames extends MICommand<MIStackListFramesInfo>
55	{	55	{
56	public MIStackListFrames(IMIExecutionDMContext execDmc) {	56	public MIStackListFrames(IMIExecutionDMContext execDmc) {
		57	this(execDmc, false);
		58	}
		59
		60	public MIStackListFrames(IMIExecutionDMContext execDmc, boolean setThread) {
57	super(execDmc, "-stack-list-frames"); //$NON-NLS-1$	61	super(execDmc, "-stack-list-frames"); //$NON-NLS-1$
		62	if (setThread) {
		63	setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()) } ); //$NON-NLS-1$
		64	}
58	}	65	}
59		66
60	public MIStackListFrames(IMIExecutionDMContext execDmc, int low, int high) {	67	public MIStackListFrames(IMIExecutionDMContext execDmc, int low, int high) {
61	super(execDmc, "-stack-list-frames", new String[]{Integer.toString(low), //$NON-NLS-1$	68	this(execDmc, false, low, high);
62	Integer.toString(high)});	69	}
		70
		71	public MIStackListFrames(IMIExecutionDMContext execDmc, boolean setThread, int low, int high) {
		72	super(execDmc, "-stack-list-frames"); //$NON-NLS-1$
		73	if (setThread) {
		74	setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()), Integer.toString(low), Integer.toString(high) } ); //$NON-NLS-1$
		75	} else {
		76	setParameters(new String[] { Integer.toString(low), Integer.toString(high) } );
		77	}
63	}	78	}
64		79
65	@Override	80	@Override




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.IMIRunControl.MIExecutionDMC;
import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointAddedEvent;
import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointRemovedEvent;
import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointUpdatedEvent;
import org.eclipse.dd.mi.service.MIBreakpoints.MIBreakpointDMContext;
import org.eclipse.dd.mi.service.MIRunControl.MIExecutionDMC;
import org.eclipse.dd.mi.service.breakpoint.actions.BreakpointActionAdapter;
import org.eclipse.dd.mi.service.command.events.MIBreakpointHitEvent;
import org.eclipse.dd.mi.service.command.events.MIGDBExitEvent;




    }

    @SuppressWarnings("unused")
	private IMIRunControl fRunControl;
    private MIMemoryCache fMemoryCache;

	/**

    	register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());

    	// Get the RunControl so we can retrieve the current Execution context
    	fRunControl = getServicesTracker().getService(IMIRunControl.class);

    	// Create the memory requests cache
    	fMemoryCache = new MIMemoryCache();

    //////////////////////////////////////////////////////////////////////////

    @DsfServiceEventHandler
	public void eventDispatched(IRunControl.IContainerResumedDMEvent e) {
		fMemoryCache.setTargetAvailable(e.getDMContext(), false);
		if (e.getReason() != StateChangeReason.STEP) {
			fMemoryCache.reset();

	}
   
    @DsfServiceEventHandler
	public void eventDispatched(IRunControl.IContainerSuspendedDMEvent e) {
		fMemoryCache.setTargetAvailable(e.getDMContext(), true);
		fMemoryCache.reset();
	}

Lines 886-892 Link Here

(-)src/org/eclipse/dd/mi/service/ExpressionService.java (-2 / +2 lines)
886		886
887		887
888	@DsfServiceEventHandler	888	@DsfServiceEventHandler
889	public void eventDispatched(IRunControl.IResumedDMEvent e) {	889	public void eventDispatched(IRunControl.IContainerResumedDMEvent e) {
890	fExpressionCache.setContextAvailable(e.getDMContext(), false);	890	fExpressionCache.setContextAvailable(e.getDMContext(), false);
891	if (e.getReason() != StateChangeReason.STEP) {	891	if (e.getReason() != StateChangeReason.STEP) {
892	fExpressionCache.reset();	892	fExpressionCache.reset();
Lines 894-900 Link Here
894	}	894	}
895		895
896	@DsfServiceEventHandler	896	@DsfServiceEventHandler
897	public void eventDispatched(IRunControl.ISuspendedDMEvent e) {	897	public void eventDispatched(IRunControl.IContainerSuspendedDMEvent e) {
898	fExpressionCache.setContextAvailable(e.getDMContext(), true);	898	fExpressionCache.setContextAvailable(e.getDMContext(), true);
899	fExpressionCache.reset();	899	fExpressionCache.reset();
900	}	900	}




import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.dsf.concurrent.RequestMonitor;
import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
import org.eclipse.dd.dsf.datamodel.AbstractDMEvent;
import org.eclipse.dd.dsf.datamodel.DMContexts;
import org.eclipse.dd.dsf.datamodel.IDMContext;
import org.eclipse.dd.dsf.datamodel.IDMEvent;
import org.eclipse.dd.dsf.debug.service.IRunControl;
import org.eclipse.dd.dsf.debug.service.IStack.IFrameDMContext;
import org.eclipse.dd.dsf.debug.service.command.CommandCache;
import org.eclipse.dd.dsf.service.AbstractDsfService;

import org.eclipse.dd.mi.service.command.commands.MIExecStepInstruction;
import org.eclipse.dd.mi.service.command.commands.MIExecUntil;
import org.eclipse.dd.mi.service.command.commands.MIThreadListIds;
import org.eclipse.dd.mi.service.command.events.IMIDMEvent;
import org.eclipse.dd.mi.service.command.events.MIBreakpointHitEvent;
import org.eclipse.dd.mi.service.command.events.MIErrorEvent;
import org.eclipse.dd.mi.service.command.events.MIEvent;
import org.eclipse.dd.mi.service.command.events.MIGDBExitEvent;
import org.eclipse.dd.mi.service.command.events.MIRunningEvent;
import org.eclipse.dd.mi.service.command.events.MISharedLibEvent;
import org.eclipse.dd.mi.service.command.events.MISignalEvent;
import org.eclipse.dd.mi.service.command.events.MISteppingRangeEvent;
import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;
import org.eclipse.dd.mi.service.command.events.MIThreadCreatedEvent;
import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;
import org.eclipse.dd.mi.service.command.events.MIWatchpointTriggerEvent;
import org.eclipse.dd.mi.service.command.output.MIInfo;
import org.eclipse.dd.mi.service.command.output.MIThreadListIdsInfo;
import org.osgi.framework.BundleContext;

 * events and track service state, to be perfectly in sync with the service
 * state.
 */
public class MIRunControl extends AbstractDsfService implements IMIRunControl
{
    private AbstractMIControl fConnection;
        implements IMIExecutionDMContext
    {
        /**
         * Integer ID that is used to identify the thread in the GDB/MI protocol.
         */
        private final int fThreadId;
    
        /**
         * Constructor for the context.  It should not be called directly by clients.
         * Instead clients should call {@link MIRunControl#createMIExecutionContext(IContainerDMContext, int)}
         * to create instances of this context based on the thread ID.
         * <p/>
         * Classes extending {@link MIRunControl} may also extend this class to include
         * additional information in the context.
         * 
         * @param sessionId Session that this context belongs to.
         * @param containerDmc The container that this context belongs to.
         * @param threadId GDB/MI thread identifier.
         */
        protected MIExecutionDMC(String sessionId, IContainerDMContext containerDmc, int threadId) {
            super(sessionId, containerDmc != null ? new IDMContext[] { containerDmc } : new IDMContext[0]);
            fThreadId = threadId;
        }
    
        /**
         * Returns the GDB/MI thread identifier of this context.
         * @return
         */
        public int getThreadId(){
            return fThreadId;
        }
        
        @Override
        public String toString() { return baseToString() + ".thread[" + fThreadId + "]"; }  //$NON-NLS-1$ //$NON-NLS-2$
    
        @Override
        public boolean equals(Object obj) {
            return super.baseEquals(obj) && ((MIExecutionDMC)obj).fThreadId == fThreadId;
        }
        
        @Override
        public int hashCode() { return super.baseHashCode() ^ fThreadId; }
    }
    
    @Immutable
    private static class ExecutionData implements IExecutionDMData {
        private final StateChangeReason fReason;
        ExecutionData(StateChangeReason reason) {
            fReason = reason;
        }
        public StateChangeReason getStateChangeReason() { return fReason; }
    }

    /**
     * Base class for events generated by the MI Run Control service.  Most events
     * generated by the MI Run Control service are directly caused by some MI event.
     * Other services may need access to the extended MI data carried in the event.
     * 
     * @param <V> DMC that this event refers to
     * @param <T> MIInfo object that is the direct cause of this event
     * @see MIRunControl
     */
    @Immutable
    protected static class RunControlEvent<V extends IDMContext, T extends MIEvent<? extends IDMContext>> extends AbstractDMEvent<V>
        implements IDMEvent<V>, IMIDMEvent
    {
        final private T fMIInfo;
        public RunControlEvent(V dmc, T miInfo) {
            super(dmc);
            fMIInfo = miInfo;
        }
        
        public T getMIEvent() { return fMIInfo; }
    }
    
    /**
     * Indicates that the given thread has been suspended.
     */
    @Immutable
    protected static class SuspendedEvent extends RunControlEvent<IExecutionDMContext, MIStoppedEvent>
        implements ISuspendedDMEvent
    {
        SuspendedEvent(IExecutionDMContext ctx, MIStoppedEvent miInfo) {
            super(ctx, miInfo);
        }
        
        public StateChangeReason getReason() {
            if (getMIEvent() instanceof MIBreakpointHitEvent) {
                return StateChangeReason.BREAKPOINT;
            } else if (getMIEvent() instanceof MISteppingRangeEvent) {
                return StateChangeReason.STEP;
            } else if (getMIEvent() instanceof MISharedLibEvent) {
                return StateChangeReason.SHAREDLIB;
            }else if (getMIEvent() instanceof MISignalEvent) {
                return StateChangeReason.SIGNAL;
            }else if (getMIEvent() instanceof MIWatchpointTriggerEvent) {
                return StateChangeReason.WATCHPOINT;
            }else if (getMIEvent() instanceof MIErrorEvent) {
                return StateChangeReason.ERROR;
            }else {
                return StateChangeReason.USER_REQUEST;
            }
        }
    }

    @Immutable
    protected static class ContainerSuspendedEvent extends SuspendedEvent
        implements IContainerSuspendedDMEvent
    {
        final IExecutionDMContext[] triggeringDmcs;
        ContainerSuspendedEvent(IContainerDMContext containerDmc, MIStoppedEvent miInfo, IExecutionDMContext triggeringDmc) {
            super(containerDmc, miInfo);
            this.triggeringDmcs = triggeringDmc != null
                ? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
        }
        
        public IExecutionDMContext[] getTriggeringContexts() {
            return triggeringDmcs;
        }
    }

    @Immutable
    protected static class ResumedEvent extends RunControlEvent<IExecutionDMContext, MIRunningEvent>
        implements IResumedDMEvent
    {
        ResumedEvent(IExecutionDMContext ctx, MIRunningEvent miInfo) {
            super(ctx, miInfo);
        }
        
        public StateChangeReason getReason() {
            switch(getMIEvent().getType()) {
                case MIRunningEvent.CONTINUE:
                    return StateChangeReason.USER_REQUEST;
                case MIRunningEvent.NEXT:
                case MIRunningEvent.NEXTI:
                    return StateChangeReason.STEP;
                case MIRunningEvent.STEP:
                case MIRunningEvent.STEPI:
                    return StateChangeReason.STEP;
                case MIRunningEvent.FINISH:
                    return StateChangeReason.STEP;
                case MIRunningEvent.UNTIL:
                case MIRunningEvent.RETURN:
                    break;
            }
            return StateChangeReason.UNKNOWN;
        }
    }

    @Immutable
    protected static class ContainerResumedEvent extends ResumedEvent
        implements IContainerResumedDMEvent
    {
        final IExecutionDMContext[] triggeringDmcs;

        ContainerResumedEvent(IContainerDMContext containerDmc, MIRunningEvent miInfo, IExecutionDMContext triggeringDmc) {
            super(containerDmc, miInfo);
            this.triggeringDmcs = triggeringDmc != null
                ? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
        }
        
        public IExecutionDMContext[] getTriggeringContexts() {
            return triggeringDmcs;
        }
    }
    
    @Immutable
    protected static class StartedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadCreatedEvent>
        implements IStartedDMEvent
    {
        StartedDMEvent(IMIExecutionDMContext executionDmc, MIThreadCreatedEvent miInfo) {
            super(executionDmc, miInfo);
        }
    }
    
    @Immutable
    protected static class ExitedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadExitEvent>
        implements IExitedDMEvent
    {
        ExitedDMEvent(IMIExecutionDMContext executionDmc, MIThreadExitEvent miInfo) {
            super(executionDmc, miInfo);
        }
    }
    
    private AbstractMIControl   fConnection;
	private CommandCache fMICommandCache;
    
    // State flags
	private boolean fSuspended = true;
    private boolean fResumePending = false;
	private boolean fStepping = false;

        fMICommandCache = new CommandCache(getSession(), fConnection);
        fMICommandCache.setContextAvailable(fConnection.getControlDMContext(), true);
        getSession().addServiceEventListener(this, null);
        
        //register(new String[]{IRunControl.class.getName(), MIRunControl.class.getName()}, new Hashtable<String,String>());
        
        rm.done();
    }





    // Last Thread ID created 
	private static int fLastThreadId;
    
	
    public CLIEventProcessor(AbstractMIControl connection, IContainerDMContext containerDmc, MIInferiorProcess inferior) {
        fCommandControl = connection;
        fInferior = inferior;

            fEventList.add(oobr);
            
            if (oobr instanceof MIConsoleStreamOutput) {
            	// Process Events of type DsfMIConsoleStreamOutput here
            	MIConsoleStreamOutput exec = (MIConsoleStreamOutput) oobr;

            	// Look for events with Pattern ^[New Thread 1077300144 (LWP 7973)
            	Pattern pattern = Pattern.compile("(^\\[New Thread.*LWP\\s*)(\\d*)", Pattern.MULTILINE); //$NON-NLS-1$
            	Matcher matcher = pattern.matcher(exec.getCString());
            	if (matcher.find()) {
            		MIEvent<?> e =  new MIThreadCreatedEvent(fContainerDmc, ++fLastThreadId);
            		fCommandControl.getSession().dispatchEvent(e, fCommandControl.getProperties());
            	}
                    // Dispatch DsfMIThreadCreatedEvent
                    fCommandControl.getSession().dispatchEvent(e, fCommandControl.getProperties());
                }
                // HACK -  For GDB thread exit events, we won't use the events generated by GDB. This event is 
                // raised in GDBRunControl class by polling and comparing the ExecutionContexts returned by
                // -thread-list-ids command. This is done as threads reported by exit event are still reported till 
                // they completely exit the system.
                // Look for Thread Exited Event with Pattern [Thread 1077300144 (LWP 23832) exited]\n
                // See bug 200615 for details.
//                pattern = Pattern.compile("(^\\[Thread.*LWP\\s)(\\d*)(.*exited.*$)",  Pattern.MULTILINE); //$NON-NLS-1$
//                matcher = pattern.matcher(exec.getCString());
//                if (matcher.find()) {
//                    DsfMIEvent e =  new DsfMIThreadExitEvent(fMapThreadIds.get(matcher.group(2)).intValue());
//                    // Dispatch DsfMIThreadExitEvent
//                    fConnection.getSession().dispatchEvent(e, fConnection.getProperties());
//                }
            }
        }
        

Lines 22-28 Link Here

(-)src/org/eclipse/dd/mi/service/command/MIRunControlEventProcessor.java (-51 / +91 lines)
22	import org.eclipse.dd.dsf.debug.service.command.IEventListener;	22	import org.eclipse.dd.dsf.debug.service.command.IEventListener;
23	import org.eclipse.dd.dsf.service.DsfServicesTracker;	23	import org.eclipse.dd.dsf.service.DsfServicesTracker;
24	import org.eclipse.dd.mi.internal.MIPlugin;	24	import org.eclipse.dd.mi.internal.MIPlugin;
25	import org.eclipse.dd.mi.service.MIRunControl;	25	import org.eclipse.dd.mi.service.IMIExecutionDMContext;
		26	import org.eclipse.dd.mi.service.IMIRunControl;
26	import org.eclipse.dd.mi.service.command.commands.MIExecContinue;	27	import org.eclipse.dd.mi.service.command.commands.MIExecContinue;
27	import org.eclipse.dd.mi.service.command.commands.MIExecFinish;	28	import org.eclipse.dd.mi.service.command.commands.MIExecFinish;
28	import org.eclipse.dd.mi.service.command.commands.MIExecNext;	29	import org.eclipse.dd.mi.service.command.commands.MIExecNext;
Lines 41-46 Link Here
41	import org.eclipse.dd.mi.service.command.events.MISignalEvent;	42	import org.eclipse.dd.mi.service.command.events.MISignalEvent;
42	import org.eclipse.dd.mi.service.command.events.MISteppingRangeEvent;	43	import org.eclipse.dd.mi.service.command.events.MISteppingRangeEvent;
43	import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;	44	import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;
		45	import org.eclipse.dd.mi.service.command.events.MIThreadCreatedEvent;
		46	import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;
44	import org.eclipse.dd.mi.service.command.events.MIWatchpointScopeEvent;	47	import org.eclipse.dd.mi.service.command.events.MIWatchpointScopeEvent;
45	import org.eclipse.dd.mi.service.command.events.MIWatchpointTriggerEvent;	48	import org.eclipse.dd.mi.service.command.events.MIWatchpointTriggerEvent;
46	import org.eclipse.dd.mi.service.command.output.MIConst;	49	import org.eclipse.dd.mi.service.command.output.MIConst;
Lines 51-57 Link Here
51	import org.eclipse.dd.mi.service.command.output.MIOutput;	54	import org.eclipse.dd.mi.service.command.output.MIOutput;
52	import org.eclipse.dd.mi.service.command.output.MIResult;	55	import org.eclipse.dd.mi.service.command.output.MIResult;
53	import org.eclipse.dd.mi.service.command.output.MIResultRecord;	56	import org.eclipse.dd.mi.service.command.output.MIResultRecord;
54	import org.eclipse.dd.mi.service.command.output.MIStatusAsyncOutput;
55	import org.eclipse.dd.mi.service.command.output.MIValue;	57	import org.eclipse.dd.mi.service.command.output.MIValue;
56		58
57	/**	59	/**
Lines 102-158 Link Here
102	}	104	}
103		105
104	public void eventReceived(Object output) {	106	public void eventReceived(Object output) {
105	for (MIOOBRecord oobr : ((MIOutput)output).getMIOOBRecords()) {	107	for (MIOOBRecord oobr : ((MIOutput)output).getMIOOBRecords()) {
106	if (oobr instanceof MIExecAsyncOutput) {	108	List<MIEvent<?>> events = new LinkedList<MIEvent<?>>();
107	MIExecAsyncOutput exec = (MIExecAsyncOutput) oobr;	109	if (oobr instanceof MIExecAsyncOutput) {
108	// Change of state.	110	MIExecAsyncOutput exec = (MIExecAsyncOutput) oobr;
109	String state = exec.getAsyncClass();	111	// Change of state.
110	if ("stopped".equals(state)) { //$NON-NLS-1$	112	String state = exec.getAsyncClass();
111	// Re-set the thread and stack level to -1 when stopped event is recvd.	113	if ("stopped".equals(state)) { //$NON-NLS-1$
112	// This is to synchronize the state between GDB back-end and AbstractMIControl.	114	// Re-set the thread and stack level to -1 when stopped event is recvd.
113	fCommandControl.resetCurrentThreadLevel();	115	// This is to synchronize the state between GDB back-end and AbstractMIControl.
114	fCommandControl.resetCurrentStackLevel();	116	fCommandControl.resetCurrentThreadLevel();
115		117	fCommandControl.resetCurrentStackLevel();
116	List<MIEvent<?>> events = new LinkedList<MIEvent<?>>();	118
117	MIResult[] results = exec.getMIResults();	119	MIResult[] results = exec.getMIResults();
118	for (int i = 0; i < results.length; i++) {	120	for (int i = 0; i < results.length; i++) {
119	String var = results[i].getVariable();	121	String var = results[i].getVariable();
120	MIValue val = results[i].getMIValue();	122	MIValue val = results[i].getMIValue();
121	if (var.equals("reason")) { //$NON-NLS-1$	123	if (var.equals("reason")) { //$NON-NLS-1$
122	if (val instanceof MIConst) {	124	if (val instanceof MIConst) {
123	String reason = ((MIConst) val).getString();	125	String reason = ((MIConst) val).getString();
124	MIEvent<?> e = createEvent(reason, exec);	126	MIEvent<?> e = createEvent(reason, exec);
125	if (e != null) {	127	if (e != null) {
126	events.add(e);	128	events.add(e);
127	continue;	129	continue;
128	}	130	}
129	}	131	}
130	}	132	}
131	}	133	}
132		134	// We were stopped for some unknown reason, for example
133	// We were stopped for some unknown reason, for example	135	// GDB for temporary breakpoints will not send the
134	// GDB for temporary breakpoints will not send the	136	// "reason" ??? still fire a stopped event.
135	// "reason" ??? still fire a stopped event.	137	if (events.isEmpty()) {
136	if (events.isEmpty()) {	138	MIEvent<?> e = MIStoppedEvent.parse(
137	MIEvent<?> e = MIStoppedEvent.parse(	139	fServicesTracker.getService(IMIRunControl.class), fContainerDmc, exec.getToken(), exec.getMIResults());
138	fServicesTracker.getService(MIRunControl.class), fContainerDmc, exec.getToken(), exec.getMIResults());	140	events.add(e);
139	events.add(e);	141	}
140	}	142
141	for (MIEvent<?> event : events) {	143	for (MIEvent<?> event : events) {
142	fCommandControl.getSession().dispatchEvent(event, fCommandControl.getProperties());	144	fCommandControl.getSession().dispatchEvent(event, fCommandControl.getProperties());
143	}	145	}
144	}	146	}
145	}	147	else if ("running".equals(state)) { //$NON-NLS-1$
146	else if (oobr instanceof MIStatusAsyncOutput) {	148	int token = exec.getToken();
147	// Nothing done .. but what about +download??	149	MIResult[] results = exec.getMIResults();
148	} else if (oobr instanceof MINotifyAsyncOutput) {	150	for (int i = 0; i < results.length; i++) {
149	// Nothing	151	String var = results[i].getVariable();
150	}	152	MIValue val = results[i].getMIValue();
151	}	153	if (var.equals("thread-id")) { //$NON-NLS-1$
		154	if (val instanceof MIConst) {
		155	String thread = ((MIConst) val).getString();
		156	MIEvent<?> evt = null;
		157	int threadId = 0;
		158	try {
		159	threadId = Integer.parseInt(thread);
		160	IMIExecutionDMContext context = fServicesTracker.getService(IMIRunControl.class).createMIExecutionContext(fContainerDmc, threadId);
		161	evt = new MIRunningEvent(context, token, MIRunningEvent.CONTINUE);
		162	}
		163	catch (NumberFormatException e) {
		164	evt = new MIRunningEvent(fContainerDmc, token, MIRunningEvent.CONTINUE);
		165
		166	}
		167	fCommandControl.getSession().dispatchEvent(evt, fCommandControl.getProperties());
		168	}
		169	}
		170	}
		171	}
		172
		173	}
		174	else if (oobr instanceof MINotifyAsyncOutput) {
		175	// Parse the string and dispatch the corresponding event
		176	MINotifyAsyncOutput exec = (MINotifyAsyncOutput) oobr;
		177	String miEvent = exec.getAsyncClass();
		178	if ("thread-created".equals(miEvent)) { //$NON-NLS-1$
		179	MIEvent<?> event = MIThreadCreatedEvent.parse(fContainerDmc, exec.getToken(), exec.getMIResults());
		180	if (event != null) {
		181	fCommandControl.getSession().dispatchEvent(event, fCommandControl.getProperties());
		182	}
		183	}
		184	else if ("thread-exited".equals(miEvent)) { //$NON-NLS-1$
		185	MIEvent<?> event = MIThreadExitEvent.parse(fContainerDmc, exec.getToken(), exec.getMIResults());
		186	if (event != null) {
		187	fCommandControl.getSession().dispatchEvent(event, fCommandControl.getProperties());
		188	}
		189	}
		190	}
		191	}
152	}	192	}
153		193
154	protected MIEvent<?> createEvent(String reason, MIExecAsyncOutput exec) {	194	protected MIEvent<?> createEvent(String reason, MIExecAsyncOutput exec) {
155	MIRunControl runControl = fServicesTracker.getService(MIRunControl.class);	195	IMIRunControl runControl = fServicesTracker.getService(IMIRunControl.class);
156	MIEvent<?> event = null;	196	MIEvent<?> event = null;
157	if ("breakpoint-hit".equals(reason)) { //$NON-NLS-1$	197	if ("breakpoint-hit".equals(reason)) { //$NON-NLS-1$
158	event = MIBreakpointHitEvent.parse(runControl, fContainerDmc, exec.getToken(), exec.getMIResults());	198	event = MIBreakpointHitEvent.parse(runControl, fContainerDmc, exec.getToken(), exec.getMIResults());
Lines 213-219 Link Here
213	else if (cmd instanceof MIExecFinish) { type = MIRunningEvent.FINISH; }	253	else if (cmd instanceof MIExecFinish) { type = MIRunningEvent.FINISH; }
214	else if (cmd instanceof MIExecReturn) { type = MIRunningEvent.RETURN; }	254	else if (cmd instanceof MIExecReturn) { type = MIRunningEvent.RETURN; }
215	else if (cmd instanceof MIExecContinue) { type = MIRunningEvent.CONTINUE; }	255	else if (cmd instanceof MIExecContinue) { type = MIRunningEvent.CONTINUE; }
216	else { type = MIRunningEvent.CONTINUE; }	256	else { type = MIRunningEvent.CONTINUE; }
217		257
218	fCommandControl.getSession().dispatchEvent(	258	fCommandControl.getSession().dispatchEvent(
219	new MIRunningEvent(fContainerDmc, id, type), fCommandControl.getProperties());	259	new MIRunningEvent(fContainerDmc, id, type), fCommandControl.getProperties());




 */
public class CLIInfoThreadsInfo extends MIInfo {

	protected List<CLIThreadInfo> info; 
	
	public CLIInfoThreadsInfo(MIOutput out) {
		super(out);
		parse();
	}

	public class CLIThreadInfo{
		String fName;
		String fGdbId;
		String fPid;
		boolean fIsCurrentThread = false;
		
		public CLIThreadInfo(String tid, String pid, String name, boolean isCurrentThread)
		{
			this.fName = name;
			this.fGdbId = tid;

		public boolean isCurrentThread(){return fIsCurrentThread; }
	}
	
	public List<CLIThreadInfo> getThreadInfo(){
		return info; 
	}

	protected void parse() {
		info = new ArrayList<CLIThreadInfo>();
		if (isDone()) {
			MIOutput out = getMIOutput();
			MIOOBRecord[] oobs = out.getMIOOBRecords();

		}
	}

	protected void parseThreadInfo(String str, List<CLIThreadInfo> info) {
			// Fetch the OS ThreadId & Find the current thread 
			if(str.length() > 0 ){
				Pattern pattern = Pattern.compile("(^\\*?\\s*\\d+)(\\s*Thread\\s*)(0x[0-9a-fA-F]+|-?\\d+)(\\s*\\(LWP\\s*)(\\d*)",  Pattern.MULTILINE); //$NON-NLS-1$

						isCurrentThread = true;
						id = id.substring(1).trim();
					}
					info.add(new CLIThreadInfo(id, matcher.group(5), "", isCurrentThread)); //$NON-NLS-1$
				}
			}
	}

Lines 13-18 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
13	org.eclipse.cdt.debug.core,	13	org.eclipse.cdt.debug.core,
14	org.eclipse.cdt.core	14	org.eclipse.cdt.core
15	Export-Package:	15	Export-Package:
		16	org.eclipse.dd.mi.internal,
16	org.eclipse.dd.mi.service,	17	org.eclipse.dd.mi.service,
17	org.eclipse.dd.mi.service.command,	18	org.eclipse.dd.mi.service.command,
18	org.eclipse.dd.mi.service.command.commands,	19	org.eclipse.dd.mi.service.command.commands,




/*******************************************************************************
 * 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 additional functionality
 *******************************************************************************/
package org.eclipse.dd.mi.service;

import org.eclipse.dd.dsf.concurrent.Immutable;
import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
import org.eclipse.dd.dsf.datamodel.AbstractDMEvent;
import org.eclipse.dd.dsf.datamodel.IDMContext;
import org.eclipse.dd.dsf.datamodel.IDMEvent;
import org.eclipse.dd.dsf.debug.service.IRunControl;
import org.eclipse.dd.mi.service.command.events.IMIDMEvent;
import org.eclipse.dd.mi.service.command.events.MIBreakpointHitEvent;
import org.eclipse.dd.mi.service.command.events.MIErrorEvent;
import org.eclipse.dd.mi.service.command.events.MIEvent;
import org.eclipse.dd.mi.service.command.events.MIRunningEvent;
import org.eclipse.dd.mi.service.command.events.MISharedLibEvent;
import org.eclipse.dd.mi.service.command.events.MISignalEvent;
import org.eclipse.dd.mi.service.command.events.MISteppingRangeEvent;
import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;
import org.eclipse.dd.mi.service.command.events.MIThreadCreatedEvent;
import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;
import org.eclipse.dd.mi.service.command.events.MIWatchpointTriggerEvent;

/**
 * This interface provides access to controlling and monitoring the execution 
 * state of a process being debugged.  This interface does not actually 
 * provide methods for creating or destroying execution contexts, it doesn't
 * even have methods for getting labels.  That's because it is expected that
 * higher level services, ones that deal with processes, kernels, or target 
 * features will provide that functionality. 
 */
public interface IMIRunControl extends IRunControl
{
	class MIExecutionDMC extends AbstractDMContext implements IMIExecutionDMContext
	{
		/**
		 * Integer ID that is used to identify the thread in the GDB/MI protocol.
		 */
		private final int fThreadId;

		/**
		 * Constructor for the context.  It should not be called directly by clients.
		 * Instead clients should call {@link MIRunControl#createMIExecutionContext(IContainerDMContext, int)}
		 * to create instances of this context based on the thread ID.
		 * <p/>
		 * Classes extending {@link MIRunControl} may also extend this class to include
		 * additional information in the context.
		 * 
		 * @param sessionId Session that this context belongs to.
		 * @param containerDmc The container that this context belongs to.
		 * @param threadId GDB/MI thread identifier.
		 */
		protected MIExecutionDMC(String sessionId, IContainerDMContext containerDmc, int threadId) {
			super(sessionId, containerDmc != null ? new IDMContext[] { containerDmc } : new IDMContext[0]);
			fThreadId = threadId;
		}

		/**
		 * Returns the GDB/MI thread identifier of this context.
		 * @return
		 */
		public int getThreadId(){
			return fThreadId;
		}

		@Override
		public String toString() { return baseToString() + ".thread[" + fThreadId + "]"; }  //$NON-NLS-1$ //$NON-NLS-2$

		@Override
		public boolean equals(Object obj) {
			return super.baseEquals(obj) && ((MIExecutionDMC)obj).fThreadId == fThreadId;
		}

		@Override
		public int hashCode() { return super.baseHashCode() ^ fThreadId; }
	}

	@Immutable
	static class ExecutionData implements IExecutionDMData {
		private final StateChangeReason fReason;
		ExecutionData(StateChangeReason reason) {
			fReason = reason;
		}
		public StateChangeReason getStateChangeReason() { return fReason; }
	}

	/**
	 * Base class for events generated by the MI Run Control service.  Most events
	 * generated by the MI Run Control service are directly caused by some MI event.
	 * Other services may need access to the extended MI data carried in the event.
	 * 
	 * @param <V> DMC that this event refers to
	 * @param <T> MIInfo object that is the direct cause of this event
	 * @see MIRunControl
	 */
	@Immutable
	static class RunControlEvent<V extends IDMContext, T extends MIEvent<? extends IDMContext>> extends AbstractDMEvent<V>
	implements IDMEvent<V>, IMIDMEvent
	{
		final private T fMIInfo;
		public RunControlEvent(V dmc, T miInfo) {
			super(dmc);
			fMIInfo = miInfo;
		}

		public T getMIEvent() { return fMIInfo; }
	}

	/**
	 * Indicates that the given thread has been suspended.
	 */
	@Immutable
	static class SuspendedEvent extends RunControlEvent<IExecutionDMContext, MIStoppedEvent>
	implements ISuspendedDMEvent
	{
		SuspendedEvent(IExecutionDMContext ctx, MIStoppedEvent miInfo) {
			super(ctx, miInfo);
		}

		public StateChangeReason getReason() {
			if (getMIEvent() instanceof MIBreakpointHitEvent) {
				return StateChangeReason.BREAKPOINT;
			} else if (getMIEvent() instanceof MISteppingRangeEvent) {
				return StateChangeReason.STEP;
			} else if (getMIEvent() instanceof MISharedLibEvent) {
				return StateChangeReason.SHAREDLIB;
			}else if (getMIEvent() instanceof MISignalEvent) {
				return StateChangeReason.SIGNAL;
			}else if (getMIEvent() instanceof MIWatchpointTriggerEvent) {
				return StateChangeReason.WATCHPOINT;
			}else if (getMIEvent() instanceof MIErrorEvent) {
				return StateChangeReason.ERROR;
			}else {
				return StateChangeReason.USER_REQUEST;
			}
		}
	}

	@Immutable
	static class ContainerSuspendedEvent extends SuspendedEvent
	implements IContainerSuspendedDMEvent
	{
		final IExecutionDMContext[] triggeringDmcs;
		ContainerSuspendedEvent(IContainerDMContext containerDmc, MIStoppedEvent miInfo, IExecutionDMContext triggeringDmc) {
			super(containerDmc, miInfo);
			this.triggeringDmcs = triggeringDmc != null
			? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
		}

		public IExecutionDMContext[] getTriggeringContexts() {
			return triggeringDmcs;
		}
	}

	@Immutable
	static class ThreadSuspendedEvent extends SuspendedEvent
	{
		ThreadSuspendedEvent(IExecutionDMContext executionDmc, MIStoppedEvent miInfo) {
			super(executionDmc, miInfo);
		}
	}

	@Immutable
	static class ResumedEvent extends RunControlEvent<IExecutionDMContext, MIRunningEvent>
	implements IResumedDMEvent
	{
		ResumedEvent(IExecutionDMContext ctx, MIRunningEvent miInfo) {
			super(ctx, miInfo);
		}

		public StateChangeReason getReason() {
			switch(getMIEvent().getType()) {
			case MIRunningEvent.CONTINUE:
				return StateChangeReason.USER_REQUEST;
			case MIRunningEvent.NEXT:
			case MIRunningEvent.NEXTI:
				return StateChangeReason.STEP;
			case MIRunningEvent.STEP:
			case MIRunningEvent.STEPI:
				return StateChangeReason.STEP;
			case MIRunningEvent.FINISH:
				return StateChangeReason.STEP;
			case MIRunningEvent.UNTIL:
			case MIRunningEvent.RETURN:
				break;
			}
			return StateChangeReason.UNKNOWN;
		}
	}

	@Immutable
	static class ContainerResumedEvent extends ResumedEvent
	implements IContainerResumedDMEvent
	{
		final IExecutionDMContext[] triggeringDmcs;

		ContainerResumedEvent(IContainerDMContext containerDmc, MIRunningEvent miInfo, IExecutionDMContext triggeringDmc) {
			super(containerDmc, miInfo);
			this.triggeringDmcs = triggeringDmc != null
			? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
		}

		public IExecutionDMContext[] getTriggeringContexts() {
			return triggeringDmcs;
		}
	}

	@Immutable
	static class ThreadResumedEvent extends ResumedEvent
	{
		ThreadResumedEvent(IExecutionDMContext executionDmc, MIRunningEvent miInfo) {
			super(executionDmc, miInfo);
		}
	}

	@Immutable
	static class StartedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadCreatedEvent>
	implements IStartedDMEvent
	{
		StartedDMEvent(IMIExecutionDMContext executionDmc, MIThreadCreatedEvent miInfo) {
			super(executionDmc, miInfo);
		}
	}

	@Immutable
	static class ExitedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadExitEvent>
	implements IExitedDMEvent
	{
		ExitedDMEvent(IMIExecutionDMContext executionDmc, MIThreadExitEvent miInfo) {
			super(executionDmc, miInfo);
		}
	}

	public IMIExecutionDMContext createMIExecutionContext(IContainerDMContext container, int threadId);
}




/*******************************************************************************
 * 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.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;

	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);
        
        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) {

	    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;
	    }

		final IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(ctx, IMIExecutionDMContext.class);
	    
	    if (execDmc == null) {
            //rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, -1, "No frame context found in " + ctx, null)); //$NON-NLS-1$
            rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid context " + ctx, null)); //$NON-NLS-1$
            rm.done();
            return;
        }

	    if (startIndex == 0 && endIndex == 0) {
	        // Try to retrieve the top stack frame from the cached stopped event.
	        if (fCachedStoppedEvent != null && 
	            fCachedStoppedEvent.getFrame() != null && 
	            execDmc.equals(fCachedStoppedEvent.getDMContext())) 
	        {
	            rm.setData(new IFrameDMContext[] { createFrameDMContext(execDmc, fCachedStoppedEvent.getFrame().getLevel()) });
	            rm.done();
	            return;
	        }
	    }

	    final MIStackListFrames miStackListCmd;
	    // firstIndex is the first index retrieved
	    final int firstIndex;
	    if (endIndex >= 0) {
	    	miStackListCmd = new MIStackListFrames(execDmc, true, startIndex, endIndex);
	    	firstIndex = startIndex;
	    } else {
	    	miStackListCmd = new MIStackListFrames(execDmc, true);
	    	firstIndex = 0;
	    }
		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) {
        IMIExecutionDMContext execDmc = DMContexts.getAncestorOfType(dmc, IMIExecutionDMContext.class);
	    if (execDmc != null) {
                MIStackInfoDepth depthCommand = null;
        	    if (maxDepth > 0) depthCommand = new MIStackInfoDepth(execDmc, true, 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();
        }
    }

    // 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;
    	}
    }

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 QNX Software 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:
 *     QNX Software Systems - Initial API and implementation
 *     Ericsson AB			- Modified for DSF Reference Implementation
 *******************************************************************************/
package org.eclipse.dd.mi.service.command.output;

import java.math.BigInteger;
import java.util.List;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.dd.dsf.concurrent.Immutable;

/**
 * GDB/MI thread list parsing.
 * 
 * Example 1:
 * 
 * -thread-info
 * ^done,threads=[
 * 	{id="2",target-id="Thread 0xb7c8ab90 (LWP 7010)",
 *		frame={level="0",addr="0x08048bba",func="my_func",args=[{name="arg",value="0xbff056f5"}],
 * 			file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="26"},
 * 			running="0"},
 * 	{id="1",target-id="Thread 0xb7c8b8d0 (LWP 7007)",
 * 		frame={level="0",addr="0x08048a77",func="timer",args=[{name="duration",value="0xbff056f5 \"10\""}],
 * 			file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="39"},
 * 			running="0"}
 * 	],current-thread-id="2"
 * 

 * Example 2:
 * 
 * -thread-info 2
 * ^done,threads=[
 * 	{id="2",target-id="Thread 0xb7c8ab90 (LWP 7010)",
 *		frame={level="0",addr="0x08048bba",func="my_func",args=[{name="arg",value="0xbff056f5"}],
 * 			file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="26"},
 * 			running="0"}
 *  ]
 * 
 * 
 * Example 3 (non-stop):
 *
 * -thread-info
 * ^done,threads=[
 * 	{id="2",target-id="Thread 0xb7c8eb90 (LWP 7807)",running="1"},
 * 	{id="1",target-id="Thread 0xb7c8b8d0 (LWP 7007)",
 * 		frame={level="0",addr="0x08048a77",func="timer",args=[{name="duration",value="0xbff056f5 \"10\""}],
 * 			file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="39"},
 * 			running="0"}
 * 	],current-thread-id="1"
 */
public class MIThreadInfoInfo extends MIInfo {

	@Immutable
	public class ThreadInfo {

		final private String      fGdbId;
		final private String      fTargetId;
		final private String      fOsId;
		final private ThreadFrame fTopFrame; 
		final private boolean     fIsRunning;
		
		public ThreadInfo(String gdbId, String targetId, String osId, ThreadFrame topFrame, boolean isRunning) {
			fGdbId     = gdbId;
			fTargetId  = targetId;
			fOsId      = osId;
			fTopFrame  = topFrame;
			fIsRunning = isRunning;
		}

		public String getGdbId()         { return fGdbId;     }
		public String getTargetId()      { return fTargetId;  }
		public String getOsId()          { return fOsId;      }
		public ThreadFrame getTopFrame() { return fTopFrame;  } 
		public boolean isRunning()       { return fIsRunning; }
	}

	@Immutable
	public class ThreadFrame {
		final private int        fStackLevel;
		final private BigInteger fAddress;
		final private String     fFunction;
		final private ThreadFrameFunctionArgs[] fArgs;
		final private String     fFileName;
		final private String     fFullName;
		final private int        fLineNumber;
		
		public ThreadFrame(int stackLevel, BigInteger address, String function,
				ThreadFrameFunctionArgs[] args,	String file, String fullName, int line)
		{
			fStackLevel = stackLevel;
			fAddress    = address;
			fFunction   = function;
			fArgs       = args;
			fFileName   = file;
			fFullName   = fullName;
			fLineNumber = line;
		}

		public int        getStackLevel() { return fStackLevel; }
		public BigInteger getAddress()    { return fAddress;    }
		public String     getFucntion()   { return fFunction;   }
		public ThreadFrameFunctionArgs[] getArgs() { return fArgs; }
		public String     getFileName()   { return fFileName;   }
		public String     getFullName()   { return fFullName;   }
		public int        getLineNumber() { return fLineNumber; }
	}

	@Immutable
	public class ThreadFrameFunctionArgs {
	}

	private int fCurrentThread = -1;
	private List<ThreadInfo> fThreadInfoList = null;
	private int[] fThreadList = null;

	public MIThreadInfoInfo(MIOutput out) {
		super(out);
		parse();
	}

	public int getCurrentThread() {
		return fCurrentThread;
	}

	public List<ThreadInfo> getThreadInfoList() {
		return fThreadInfoList;
	}

	public int[] getThreadList() {
		return fThreadList;
	}

	// General format:
	//		threads=[{...}],current-thread-id="n"
	private void parse() {
		if (isDone()) {
			MIOutput out = getMIOutput();
			MIResultRecord rr = out.getMIResultRecord();
			if (rr != null) {
				MIResult[] results =  rr.getMIResults();
				for (int i = 0; i < results.length; i++) {
					String var = results[i].getVariable();
					if (var.equals("threads")) { //$NON-NLS-1$
						MIValue val = results[i].getMIValue();
						if (val instanceof MIList) {
							parseThreads((MIList) val);
						}
					}
					else if (var.equals("current-thread-id")) { //$NON-NLS-1$
						MIValue value = results[i].getMIValue();
						if (value instanceof MIConst) {
							String str = ((MIConst) value).getCString();
							try {
								fCurrentThread = Integer.parseInt(str.trim());
							} catch (NumberFormatException e) {
								fCurrentThread = -1;
							}
						}
					}
				}
			}
		}
		if (fThreadInfoList == null) {
			fThreadInfoList = new Vector<ThreadInfo>(0);
			fThreadList = new int[0];
		}
	}

	// General formats:
	//		id="n",target-id="Thread 0xb7c8ab90 (LWP 7010)",frame={...},running="0"
	//		id="n",target-id="Thread 0xb7c8eb90 (LWP 7807)",running="1"
	private void parseThreads(MIList list) {
		MIValue[] values = list.getMIValues();
		fThreadInfoList = new Vector<ThreadInfo>(values.length);
		fThreadList = new int[values.length];
		
		for (int i = 0; i < values.length; i++) {
			MITuple value = (MITuple) values[i];
			MIResult[] results = value.getMIResults();

			String gdbId = null;
			String targetId = null;
			String osId = null;
			ThreadFrame topFrame = null;
			boolean isRunning = false;

			for (int j = 0; j < results.length; j++) {
				MIResult result = results[j];
				String var = result.getVariable();
				if (var.equals("id")) { //$NON-NLS-1$
					MIValue val = results[j].getMIValue();
					if (val instanceof MIConst) {
						gdbId = ((MIConst) val).getCString();
					}
				}
				else if (var.equals("target-id")) { //$NON-NLS-1$
					MIValue val = results[j].getMIValue();
					if (val instanceof MIConst) {
						targetId = ((MIConst) val).getCString();
						osId = parseOsId(targetId);
					}
				}
				else if (var.equals("frame")) { //$NON-NLS-1$
					MIValue val = results[j].getMIValue();
					topFrame = parseFrame(val);
				}
				else if (var.equals("running")) { //$NON-NLS-1$
					MIValue val = results[j].getMIValue();
					if (val instanceof MIConst) {
						String v = ((MIConst) val).getCString();
						isRunning = v.equals("1"); //$NON-NLS-1$
					}
				}
			}
			
			fThreadInfoList.add(new ThreadInfo(gdbId, targetId, osId, topFrame, isRunning));
			try {
				fThreadList[i] = Integer.parseInt(gdbId);
			} catch (NumberFormatException e) {
			}
		}
	}

	// General format:
	// 		"Thread 0xb7c8ab90 (LWP 7010)"
	private String parseOsId(String str) {
		Pattern pattern = Pattern.compile("(Thread\\s*)(0x[0-9a-fA-F]+|-?\\d+)(\\s*\\(LWP\\s*)(\\d*)", 0); //$NON-NLS-1$
		Matcher matcher = pattern.matcher(str);
		if (matcher.find()) {
			return matcher.group(4);
		}
		return null;
	}

	// General format:
	// 		level="0",addr="0x08048bba",func="func",args=[...],file="file.cc",fullname="/path/file.cc",line="26"
	private ThreadFrame parseFrame(MIValue val) {
		// TODO Auto-generated method stub
		return null;
	}

}





/*******************************************************************************
 * Copyright (c) 2000, 2006 QNX Software 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:
 *     QNX Software Systems - Initial API and implementation
 *     Ericsson				- Modified for new DSF Reference Implementation
 *******************************************************************************/

package org.eclipse.dd.mi.service.command.commands;

import org.eclipse.dd.dsf.debug.service.IRunControl.IContainerDMContext;
import org.eclipse.dd.mi.service.command.output.MIOutput;
import org.eclipse.dd.mi.service.command.output.MIThreadInfoInfo;

/**
 * 
 * -thread-info [ thread-id ]
 *
 * Reports information about either a specific thread, if [thread-id] is present,
 * or about all threads. When printing information about all threads, also reports
 * the current thread.
 * 
 */
public class MIThreadInfo extends MICommand<MIThreadInfoInfo> {
	
	public MIThreadInfo(IContainerDMContext dmc) {
		super(dmc, "-thread-info"); //$NON-NLS-1$
	}

	public MIThreadInfo(IContainerDMContext dmc, int threadId) {
		super(dmc, "-thread-info", new String[]{ Integer.toString(threadId) }); //$NON-NLS-1$
	}

    @Override
    public MIThreadInfoInfo getResult(MIOutput out) {
        return new MIThreadInfoInfo(out);
    }
}




/*******************************************************************************
 * 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	AB		  - Modified for handling of multiple threads
 *******************************************************************************/

package org.eclipse.dd.mi.service;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
import org.eclipse.dd.dsf.concurrent.RequestMonitor;
import org.eclipse.dd.dsf.datamodel.DMContexts;
import org.eclipse.dd.dsf.datamodel.IDMContext;
import org.eclipse.dd.dsf.datamodel.IDMEvent;
import org.eclipse.dd.dsf.debug.service.IStack.IFrameDMContext;
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.MIExecContinue;
import org.eclipse.dd.mi.service.command.commands.MIExecFinish;
import org.eclipse.dd.mi.service.command.commands.MIExecInterrupt;
import org.eclipse.dd.mi.service.command.commands.MIExecNext;
import org.eclipse.dd.mi.service.command.commands.MIExecNextInstruction;
import org.eclipse.dd.mi.service.command.commands.MIExecStep;
import org.eclipse.dd.mi.service.command.commands.MIExecStepInstruction;
import org.eclipse.dd.mi.service.command.commands.MIExecUntil;
import org.eclipse.dd.mi.service.command.commands.MIThreadListIds;
import org.eclipse.dd.mi.service.command.events.MIGDBExitEvent;
import org.eclipse.dd.mi.service.command.events.MIRunningEvent;
import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;
import org.eclipse.dd.mi.service.command.events.MIThreadCreatedEvent;
import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;
import org.eclipse.dd.mi.service.command.output.MIInfo;
import org.eclipse.dd.mi.service.command.output.MIThreadListIdsInfo;
import org.osgi.framework.BundleContext;

/**
 * Implementation note: This class implements event handlers for the events that
 * are generated by this service itself. When the event is dispatched, these
 * handlers will be called first, before any of the clients. These handlers
 * update the service's internal state information to make them consistent with
 * the events being issued. Doing this in the handlers as opposed to when the
 * events are generated, guarantees that the state of the service will always be
 * consistent with the events. The purpose of this pattern is to allow clients
 * that listen to service events and track service state, to be perfectly in
 * sync with the service state.
 */
public class MIRunControlNS extends AbstractDsfService implements
		IMIRunControl {

	protected class MIThreadRunState {
		// State flags
		boolean fSuspended = false;
		boolean fResumePending = false;
		boolean fStepping = false;
		StateChangeReason fStateChangeReason;
	}

	///////////////////////////////////////////////////////////////////////////
	// MIRunControlNS
	///////////////////////////////////////////////////////////////////////////

	private AbstractMIControl fConnection;

	private boolean fTerminated = false;

	// ThreadStates indexed by the execution context
	protected Map<IMIExecutionDMContext, MIThreadRunState> fThreadRunStates = new HashMap<IMIExecutionDMContext, MIThreadRunState>();

	///////////////////////////////////////////////////////////////////////////
	// Initialization and shutdown
	///////////////////////////////////////////////////////////////////////////

	public MIRunControlNS(DsfSession session) {
		super(session);
	}

	@Override
	public void initialize(final RequestMonitor rm) {
		super.initialize(new RequestMonitor(getExecutor(), rm) {
			@Override
			protected void handleSuccess() {
				doInitialize(rm);
			}
		});
	}

	private void doInitialize(final RequestMonitor rm) {
		fConnection = getServicesTracker().getService(AbstractMIControl.class);
		getSession().addServiceEventListener(this, null);
		rm.done();
	}

	@Override
	public void shutdown(final RequestMonitor rm) {
		getSession().removeServiceEventListener(this);
		super.shutdown(rm);
	}

	///////////////////////////////////////////////////////////////////////////
	// AbstractDsfService
	///////////////////////////////////////////////////////////////////////////

	@Override
	protected BundleContext getBundleContext() {
		return MIPlugin.getBundleContext();
	}

	///////////////////////////////////////////////////////////////////////////
	// IDMService
	///////////////////////////////////////////////////////////////////////////

	@SuppressWarnings("unchecked")
	public void getModelData(IDMContext dmc, DataRequestMonitor<?> rm) {
		if (dmc instanceof IExecutionDMContext) {
			getExecutionData((IExecutionDMContext) dmc, (DataRequestMonitor<IExecutionDMData>) rm);
		} else {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE, "Unknown DMC type", null)); //$NON-NLS-1$
			rm.done();
		}
	}

	///////////////////////////////////////////////////////////////////////////
	// IRunControl
	///////////////////////////////////////////////////////////////////////////

	// ------------------------------------------------------------------------
	// Suspend
	// ------------------------------------------------------------------------

	public boolean isSuspended(IExecutionDMContext context) {

		// Thread case
		if (context instanceof MIExecutionDMC) {
			MIThreadRunState threadState = fThreadRunStates.get(context);
			return (threadState == null) ? false : !fTerminated && threadState.fSuspended;
		}

		// Container case
		if (context instanceof IContainerDMContext) {
			boolean isSuspended = false;
			for (IMIExecutionDMContext threadContext : fThreadRunStates.keySet()) {
				if (DMContexts.isAncestorOf(threadContext, context)) {
					isSuspended |= isSuspended(threadContext);
				}
			}
			return isSuspended;
		}

		// Default case
		return false;
	}

	public void canSuspend(IExecutionDMContext context, DataRequestMonitor<Boolean> rm) {

		// Thread case
		if (context instanceof MIExecutionDMC) {
			rm.setData(doCanSuspend(context));
			rm.done();
			return;
		}

		// Container case
		if (context instanceof IContainerDMContext) {
			boolean canSuspend = false;
			for (IMIExecutionDMContext threadContext : fThreadRunStates.keySet()) {
				if (DMContexts.isAncestorOf(threadContext, context)) {
					canSuspend |= doCanSuspend(threadContext);
				}
			}
			rm.setData(canSuspend);
			rm.done();
			return;
		}

		// Default case
		rm.setData(false);
		rm.done();
	}

	private boolean doCanSuspend(IExecutionDMContext context) {
		MIThreadRunState threadState = fThreadRunStates.get(context);
		return (threadState == null) ? false : !fTerminated && !threadState.fSuspended;
	}

	public void suspend(IExecutionDMContext context, final RequestMonitor rm) {

		assert context != null;

		// Thread case
		IMIExecutionDMContext thread = DMContexts.getAncestorOfType(context, IMIExecutionDMContext.class);
		if (thread != null) {
			doSuspendThread(thread, rm);
			return;
		}

		// Container case
		IContainerDMContext container = DMContexts.getAncestorOfType(context, IContainerDMContext.class);
		if (container != null) {
			doSuspendContainer(container, rm);
			return;
		}

		// Default case
		rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, NOT_SUPPORTED, "Invalid context type.", null)); //$NON-NLS-1$
		rm.done();
	}

	private void doSuspendThread(IMIExecutionDMContext context, final RequestMonitor rm) {

		if (!doCanSuspend(context)) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, NOT_SUPPORTED,
				"Given context: " + context + ", is already suspended.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}

		MIExecInterrupt cmd = new MIExecInterrupt(context, true);
		fConnection.queueCommand(cmd, new DataRequestMonitor<MIInfo>(getExecutor(), rm));
	}

	private void doSuspendContainer(IExecutionDMContext context, final RequestMonitor rm) {
		MIExecInterrupt cmd = new MIExecInterrupt(context, true);
		fConnection.queueCommand(cmd, new DataRequestMonitor<MIInfo>(getExecutor(), rm));
	}

	// ------------------------------------------------------------------------
	// Resume
	// ------------------------------------------------------------------------

	public void canResume(IExecutionDMContext context, DataRequestMonitor<Boolean> rm) {

		// Thread case
		if (context instanceof MIExecutionDMC) {
			rm.setData(doCanResume(context));
			rm.done();
			return;
		}

		// Container case
		if (context instanceof IContainerDMContext) {
			boolean canSuspend = false;
			for (IMIExecutionDMContext threadContext : fThreadRunStates.keySet()) {
				if (DMContexts.isAncestorOf(threadContext, context)) {
					canSuspend |= doCanResume(threadContext);
				}
			}
			rm.setData(canSuspend);
			rm.done();
			return;
		}

		// Default case
		rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, NOT_SUPPORTED, "Invalid context type.", null)); //$NON-NLS-1$
		rm.done();
	}

	private boolean doCanResume(IExecutionDMContext context) {
		MIThreadRunState threadState = fThreadRunStates.get(context);
		return (threadState == null) ? false : !fTerminated && threadState.fSuspended && !threadState.fResumePending;
	}

	public void resume(IExecutionDMContext context, final RequestMonitor rm) {

		assert context != null;

		// Thread case
		IMIExecutionDMContext thread = DMContexts.getAncestorOfType(context, IMIExecutionDMContext.class);
		if (thread != null) {
			doResumeThread(thread, rm);
			return;
		}

		// Container case
		IContainerDMContext container = DMContexts.getAncestorOfType(context, IContainerDMContext.class);
		if (container != null) {
			doResumeContainer(container, rm);
			return;
		}

		// Default case
		rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, NOT_SUPPORTED, "Invalid context type.", null)); //$NON-NLS-1$
		rm.done();
	}

	private void doResumeThread(IMIExecutionDMContext context, final RequestMonitor rm) {

		if (!doCanResume(context)) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_STATE,
				"Given context: " + context + ", is already running.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}

		MIThreadRunState threadState = fThreadRunStates.get(context);
		if (threadState == null) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_STATE,
				"Given context: " + context + " is not an MI execution context.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}
		threadState.fResumePending = true;

		MIExecContinue cmd = new MIExecContinue(context, true);
		fConnection.queueCommand(cmd, new DataRequestMonitor<MIInfo>(getExecutor(), rm));
	}

	private void doResumeContainer(IExecutionDMContext context, final RequestMonitor rm) {
		MIExecContinue cmd = new MIExecContinue(context, true);
		fConnection.queueCommand(cmd, new DataRequestMonitor<MIInfo>(getExecutor(), rm));
	}

	// ------------------------------------------------------------------------
	// Step
	// ------------------------------------------------------------------------

	public boolean isStepping(IExecutionDMContext context) {

		// If it's a thread, just look it up
		if (context instanceof MIExecutionDMC) {
			MIThreadRunState threadState = fThreadRunStates.get(context);
			return (threadState == null) ? false : !fTerminated && threadState.fStepping;
		}

		// Default case
		return false;
	}

	public void canStep(IExecutionDMContext context, StepType stepType, DataRequestMonitor<Boolean> rm) {

		// If it's a thread, just look it up
		if (context instanceof MIExecutionDMC) {
			canResume(context, rm);
			return;
		}

		// If it's a container, then we don't want to step it
		rm.setData(false);
		rm.done();
	}

	public void step(IExecutionDMContext context, StepType stepType, final RequestMonitor rm) {

		assert context != null;

		IMIExecutionDMContext dmc = DMContexts.getAncestorOfType(context, IMIExecutionDMContext.class);
		if (dmc == null) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, NOT_SUPPORTED,
				"Given context: " + context + " is not an MI execution context.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}

		if (!doCanResume(context)) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_STATE,
				"Cannot resume context", null)); //$NON-NLS-1$
			rm.done();
			return;
		}

		MIThreadRunState threadState = fThreadRunStates.get(context);
		if (threadState == null) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_STATE,
				"Given context: " + context + " can't be found.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}

		threadState.fResumePending = true;
		threadState.fStepping = true;

		switch (stepType) {
		case STEP_INTO:
			fConnection.queueCommand(new MIExecStep(dmc, true),
					new DataRequestMonitor<MIInfo>(getExecutor(), rm));
			break;
		case STEP_OVER:
			fConnection.queueCommand(new MIExecNext(dmc, true),
					new DataRequestMonitor<MIInfo>(getExecutor(), rm));
			break;
		case STEP_RETURN:
			// The -exec-finish command operates on the selected stack frame, but here we always
			// want it to operate on the stop stack frame. So we manually create a top-frame
			// context to use with the MI command.
			// We get a local instance of the stack service because the stack service can be shut
			// down before the run control service is shut down. So it is possible for the
			// getService() request below to return null.
			MIStack stackService = getServicesTracker().getService(MIStack.class);
			if (stackService != null) {
				IFrameDMContext topFrameDmc = stackService.createFrameDMContext(dmc, 0);
				fConnection.queueCommand(new MIExecFinish(topFrameDmc),
						new DataRequestMonitor<MIInfo>(getExecutor(), rm));
			} else {
				rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, NOT_SUPPORTED,
						"Cannot create context for command, stack service not available.", null)); //$NON-NLS-1$
				rm.done();
			}
			break;
		case INSTRUCTION_STEP_INTO:
			fConnection.queueCommand(new MIExecStepInstruction(dmc, true),
					new DataRequestMonitor<MIInfo>(getExecutor(), rm));
			break;
		case INSTRUCTION_STEP_OVER:
			fConnection.queueCommand(new MIExecNextInstruction(dmc, true),
					new DataRequestMonitor<MIInfo>(getExecutor(), rm));
			break;
		default:
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID,
					INTERNAL_ERROR, "Given step type not supported", null)); //$NON-NLS-1$
			rm.done();
		}
	}

	// ------------------------------------------------------------------------
	// Run to line
	// ------------------------------------------------------------------------

	// Later add support for Address and function.
	// skipBreakpoints is not used at the moment. Implement later
	public void runToLine(IExecutionDMContext context, String fileName, String lineNo, boolean skipBreakpoints, final DataRequestMonitor<MIInfo> rm) {

		assert context != null;

		IMIExecutionDMContext dmc = DMContexts.getAncestorOfType(context, IMIExecutionDMContext.class);
		if (dmc == null) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, NOT_SUPPORTED,
				"Given context: " + context + " is not an MI execution context.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}

		if (!doCanResume(context)) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_STATE,
				"Cannot resume context", null)); //$NON-NLS-1$
			rm.done();
			return;
		}

		MIThreadRunState threadState = fThreadRunStates.get(context);
		if (threadState == null) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_STATE,
				"Given context: " + context + " is not an MI execution context.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}

		threadState.fResumePending = true;
		fConnection.queueCommand(new MIExecUntil(dmc, fileName + ":" + lineNo), //$NON-NLS-1$
				new DataRequestMonitor<MIInfo>(getExecutor(), rm));
	}

	// ------------------------------------------------------------------------
	// Support functions
	// ------------------------------------------------------------------------

	public void getExecutionContexts(final IContainerDMContext containerDmc, final DataRequestMonitor<IExecutionDMContext[]> rm) {
		fConnection.queueCommand(new MIThreadListIds(containerDmc),
				new DataRequestMonitor<MIThreadListIdsInfo>(getExecutor(), rm) {
					@Override
					protected void handleSuccess() {
						rm.setData(makeExecutionDMCs(containerDmc, getData()));
						rm.done();
					}
				});
	}

	private IExecutionDMContext[] makeExecutionDMCs(IContainerDMContext containerCtx, MIThreadListIdsInfo info) {
		IExecutionDMContext[] executionDmcs = new IMIExecutionDMContext[info.getThreadIds().length];
		for (int i = 0; i < info.getThreadIds().length; i++) {
			executionDmcs[i] = createMIExecutionContext(containerCtx, info.getThreadIds()[i]);
		}
		return executionDmcs;
	}

	public void getExecutionData(IExecutionDMContext dmc, DataRequestMonitor<IExecutionDMData> rm) {
		MIThreadRunState threadState = fThreadRunStates.get(dmc);
		if (threadState == null) {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID,INVALID_HANDLE,
				"Given context: " + dmc + " is not a recognized execution context.", null)); //$NON-NLS-1$ //$NON-NLS-2$
			rm.done();
			return;
		}

		if (dmc instanceof IMIExecutionDMContext) {
			rm.setData(new ExecutionData(threadState.fSuspended ? threadState.fStateChangeReason : null));
		} else {
			rm.setStatus(new Status(IStatus.ERROR, MIPlugin.PLUGIN_ID, INVALID_HANDLE,
				"Given context: " + dmc + " is not a recognized execution context.", null)); //$NON-NLS-1$ //$NON-NLS-2$
		}
		rm.done();
	}

	///////////////////////////////////////////////////////////////////////////
	// IMIRunControl
	///////////////////////////////////////////////////////////////////////////

	public IMIExecutionDMContext createMIExecutionContext(IContainerDMContext container, int threadId) {
		return new MIExecutionDMC(getSession().getId(), container, threadId);
	}

	///////////////////////////////////////////////////////////////////////////
	// IMIRunControl
	///////////////////////////////////////////////////////////////////////////

	public CommandCache getCache() {
		return null;
	}

	public AbstractMIControl getConnection() {
		return fConnection;
	}

	///////////////////////////////////////////////////////////////////////////
	// Event handlers
	///////////////////////////////////////////////////////////////////////////

	@DsfServiceEventHandler
	public void eventDispatched(final MIRunningEvent e) {

		IDMEvent<?> event = null;

		// If it's not an execution context (what else could it be?!?), just propagate it 
		IMIExecutionDMContext executionDmc = DMContexts.getAncestorOfType(e.getDMContext(), IMIExecutionDMContext.class);
		if (executionDmc == null) {
			event = new ResumedEvent(e.getDMContext(), e);
			getSession().dispatchEvent(event, getProperties());
			return;
		}

		// It's a thread execution context (since we are in non-stop mode)
		event = new ThreadResumedEvent(e.getDMContext(), e);
		updateThreadState(executionDmc, (ThreadResumedEvent) event);
		getSession().dispatchEvent(event, getProperties());

		// Find the container context, which is used in multi-threaded debugging.
        IContainerDMContext containerDmc = DMContexts.getAncestorOfType(e.getDMContext(), IContainerDMContext.class);
        if (containerDmc != null) {
        	// If there is a single stopped thread in that container, bail out.
        	for (IExecutionDMContext ctx : fThreadRunStates.keySet()) {
        		if (containerDmc.equals(ctx.getParents()[0])) {
        			if (fThreadRunStates.get(ctx).fSuspended)
        				return;
        		}
        	}
        	// Else, all threads are running so the container can't accept any commands
        	IExecutionDMContext triggeringCtx = !e.getDMContext().equals(containerDmc) ? e.getDMContext() : null;
            event = new ContainerResumedEvent(containerDmc, e, triggeringCtx);
            getSession().dispatchEvent(event, getProperties());
        }
	}

	private void updateThreadState(IMIExecutionDMContext context, ThreadResumedEvent event) {
		StateChangeReason reason = event.getReason();
		boolean isStepping = reason.equals(StateChangeReason.STEP);
		MIThreadRunState threadState = fThreadRunStates.get(context);
		if (threadState == null) {
			threadState = new MIThreadRunState();
			fThreadRunStates.put(context, threadState);
		}
		threadState.fSuspended = false;
		threadState.fResumePending = false;
		threadState.fStateChangeReason = reason;
		threadState.fStepping = isStepping;
	}

	@DsfServiceEventHandler
	public void eventDispatched(final MIStoppedEvent e) {

		IDMEvent<?> event = null;

		// If it's not an execution context (what else could it be?!?), just propagate it 
		IMIExecutionDMContext executionDmc = DMContexts.getAncestorOfType(e.getDMContext(), IMIExecutionDMContext.class);
		if (executionDmc == null) {
			event = new SuspendedEvent(e.getDMContext(), e);
			getSession().dispatchEvent(event, getProperties());
			return;
		}

		// It's a thread execution context (since we are in non-stop mode)
		event = new ThreadSuspendedEvent(e.getDMContext(), e);
		updateThreadState(executionDmc, (ThreadSuspendedEvent) event);
		getSession().dispatchEvent(event, getProperties());

		// Find the container context, which is used in multi-threaded debugging.
        IContainerDMContext containerDmc = DMContexts.getAncestorOfType(e.getDMContext(), IContainerDMContext.class);
        if (containerDmc != null) {
        	IExecutionDMContext triggeringCtx = !e.getDMContext().equals(containerDmc) ? e.getDMContext() : null;
            event = new ContainerSuspendedEvent(containerDmc, e, triggeringCtx);
            getSession().dispatchEvent(event, getProperties());
        }
	}

	private void updateThreadState(IMIExecutionDMContext context, ThreadSuspendedEvent event) {
		StateChangeReason reason = event.getReason();
		MIThreadRunState threadState = fThreadRunStates.get(context);
		if (threadState == null) {
			threadState = new MIThreadRunState();
			fThreadRunStates.put(context, threadState);
		}
		threadState.fSuspended = true;
		threadState.fResumePending = false;
		threadState.fStepping = false;
		threadState.fStateChangeReason = reason;
	}

	@DsfServiceEventHandler
	public void eventDispatched(final MIThreadCreatedEvent e) {
		IContainerDMContext containerDmc = e.getDMContext();
		IMIExecutionDMContext executionCtx = null;
		if (e.getId() != -1) {
			executionCtx = createMIExecutionContext(containerDmc, e.getId());
			if (fThreadRunStates.get(executionCtx) == null) {
				fThreadRunStates.put(executionCtx, new MIThreadRunState());
			}
		}
		getSession().dispatchEvent(new StartedDMEvent(executionCtx, e),	getProperties());
	}

	@DsfServiceEventHandler
	public void eventDispatched(final MIThreadExitEvent e) {
		IContainerDMContext containerDmc = e.getDMContext();
		IMIExecutionDMContext executionCtx = null;
		if (e.getId() != -1) {
			executionCtx = createMIExecutionContext(containerDmc, e.getId());
			fThreadRunStates.remove(executionCtx);
		}
		getSession().dispatchEvent(new ExitedDMEvent(executionCtx, e), getProperties());
	}

	@DsfServiceEventHandler
	public void eventDispatched(ThreadResumedEvent e) {
		IMIExecutionDMContext context = DMContexts.getAncestorOfType(e.getDMContext(), IMIExecutionDMContext.class);
		if (context == null) {
			return;
		}
	}

	@DsfServiceEventHandler
	public void eventDispatched(ThreadSuspendedEvent e) {
		IMIExecutionDMContext context = DMContexts.getAncestorOfType(e.getDMContext(), IMIExecutionDMContext.class);
		if (context == null) {
			return;
		}
	}

	@DsfServiceEventHandler
	public void eventDispatched(ContainerResumedEvent e) {
		IMIExecutionDMContext context = DMContexts.getAncestorOfType(e.getDMContext(), IMIExecutionDMContext.class);
		if (context == null) {
			return;
		}
	}

	@DsfServiceEventHandler
	public void eventDispatched(ContainerSuspendedEvent e) {
		IMIExecutionDMContext context = DMContexts.getAncestorOfType(e.getDMContext(), IMIExecutionDMContext.class);
		if (context == null) {
			return;
		}
	}

	@DsfServiceEventHandler
	public void eventDispatched(MIGDBExitEvent e) {
		fTerminated = true;
	}

}

Lines 37-43 Link Here

(-)src/org/eclipse/dd/dsf/debug/service/IRunControl.java (-1 / +1 lines)
37		37
38	/**	38	/**
39	* Context representing a process, kernel, or some other logical container	39	* Context representing a process, kernel, or some other logical container
40	* for execution cotnexts, which by itself can perform run-control	40	* for execution contexts, which by itself can perform run-control
41	* operations.	41	* operations.
42	*/	42	*/
43		43




import org.eclipse.dd.dsf.ui.concurrent.ViewerDataRequestMonitor;
import org.eclipse.dd.dsf.ui.viewmodel.datamodel.AbstractDMVMProvider;
import org.eclipse.dd.dsf.ui.viewmodel.datamodel.IDMVMContext;
import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl;
import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl.GDBThreadData;
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementCompareRequest;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementLabelProvider;

    @Override
    protected void updateLabelInSessionThread(ILabelUpdate[] updates) {
        for (final ILabelUpdate update : updates) {
        	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
            if ( runControl == null ) {
                    handleFailedUpdate(update);
                    continue;


                    // We're in a new dispatch cycle, and we have to check whether the
                    // service reference is still valid.
                    final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
                    if ( runControl == null ) {
                        handleFailedUpdate(update);
                        return;




import org.eclipse.dd.dsf.ui.viewmodel.VMDelta;
import org.eclipse.dd.dsf.ui.viewmodel.datamodel.AbstractDMVMProvider;
import org.eclipse.dd.dsf.ui.viewmodel.datamodel.IDMVMContext;
import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl;
import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl.GDBProcessData;
import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;
import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControlDMContext;
import org.eclipse.dd.mi.service.command.MIInferiorProcess;

	
    @Override
	protected void updateLabelInSessionThread(final ILabelUpdate update) {
    	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
        if ( runControl == null ) {
            handleFailedUpdate(update);
            return;

                    	try {
                            getSession().getExecutor().execute(new DsfRunnable() {
                                public void run() {
                                	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
                                	if ( runControl != null ) {
                                		runControl.getProcessData(
                                		    procDmc,

                	try {
                        getSession().getExecutor().execute(new DsfRunnable() {
                            public void run() {
                            	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
                            	if ( runControl != null ) {
                            		runControl.getProcessData(
                            		    procDmc,

Lines 45-50 Link Here

(-)src/org/eclipse/dd/gdb/internal/ui/launching/GdbDebuggerPage.java (+31 lines)
45	protected TabFolder fTabFolder;	45	protected TabFolder fTabFolder;
46	protected Text fGDBCommandText;	46	protected Text fGDBCommandText;
47	protected Text fGDBInitText;	47	protected Text fGDBInitText;
		48	protected Button fNonStopCheckBox;
48	private IMILaunchConfigurationComponent fSolibBlock;	49	private IMILaunchConfigurationComponent fSolibBlock;
49	private boolean fIsInitializing = false;	50	private boolean fIsInitializing = false;
50		51
Lines 64-69 Link Here
64	IGDBLaunchConfigurationConstants.DEBUGGER_DEBUG_NAME_DEFAULT);	65	IGDBLaunchConfigurationConstants.DEBUGGER_DEBUG_NAME_DEFAULT);
65	configuration.setAttribute(IGDBLaunchConfigurationConstants.ATTR_GDB_INIT,	66	configuration.setAttribute(IGDBLaunchConfigurationConstants.ATTR_GDB_INIT,
66	IGDBLaunchConfigurationConstants.DEBUGGER_GDB_INIT_DEFAULT);	67	IGDBLaunchConfigurationConstants.DEBUGGER_GDB_INIT_DEFAULT);
		68	configuration.setAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_NON_STOP,
		69	IGDBLaunchConfigurationConstants.DEBUGGER_NON_STOP_DEFAULT);
		70
67	if (fSolibBlock != null)	71	if (fSolibBlock != null)
68	fSolibBlock.setDefaults(configuration);	72	fSolibBlock.setDefaults(configuration);
69	}	73	}
Lines 86-91 Link Here
86	setInitializing(true);	90	setInitializing(true);
87	String gdbCommand = IGDBLaunchConfigurationConstants.DEBUGGER_DEBUG_NAME_DEFAULT;	91	String gdbCommand = IGDBLaunchConfigurationConstants.DEBUGGER_DEBUG_NAME_DEFAULT;
88	String gdbInit = IGDBLaunchConfigurationConstants.DEBUGGER_GDB_INIT_DEFAULT;	92	String gdbInit = IGDBLaunchConfigurationConstants.DEBUGGER_GDB_INIT_DEFAULT;
		93	boolean nonStopMode = IGDBLaunchConfigurationConstants.DEBUGGER_NON_STOP_DEFAULT;
		94
89	try {	95	try {
90	gdbCommand = configuration.getAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUG_NAME,	96	gdbCommand = configuration.getAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUG_NAME,
91	IGDBLaunchConfigurationConstants.DEBUGGER_DEBUG_NAME_DEFAULT);	97	IGDBLaunchConfigurationConstants.DEBUGGER_DEBUG_NAME_DEFAULT);
Lines 99-108 Link Here
99	catch(CoreException e) {	105	catch(CoreException e) {
100	}	106	}
101		107
		108	try {
		109	nonStopMode = configuration.getAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_NON_STOP,
		110	IGDBLaunchConfigurationConstants.DEBUGGER_NON_STOP_DEFAULT);
		111	}
		112	catch(CoreException e) {
		113	}
		114
102	if (fSolibBlock != null)	115	if (fSolibBlock != null)
103	fSolibBlock.initializeFrom(configuration);	116	fSolibBlock.initializeFrom(configuration);
104	fGDBCommandText.setText(gdbCommand);	117	fGDBCommandText.setText(gdbCommand);
105	fGDBInitText.setText(gdbInit);	118	fGDBInitText.setText(gdbInit);
		119	fNonStopCheckBox.setSelection(nonStopMode);
106		120
107	setInitializing(false);	121	setInitializing(false);
108	}	122	}
Lines 112-117 Link Here
112	fGDBCommandText.getText().trim());	126	fGDBCommandText.getText().trim());
113	configuration.setAttribute(IGDBLaunchConfigurationConstants.ATTR_GDB_INIT,	127	configuration.setAttribute(IGDBLaunchConfigurationConstants.ATTR_GDB_INIT,
114	fGDBInitText.getText().trim());	128	fGDBInitText.getText().trim());
		129	configuration.setAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_NON_STOP,
		130	fNonStopCheckBox.getSelection());
115		131
116	if (fSolibBlock != null)	132	if (fSolibBlock != null)
117	fSolibBlock.performApply(configuration);	133	fSolibBlock.performApply(configuration);
Lines 242-249 Link Here
242	fGDBInitText.setText(res);	258	fGDBInitText.setText(res);
243	}	259	}
244	});	260	});
		261
		262	// TODO: Fetch the string from LaunchUIMessages
		263	// TODO: Ideally, this field should be disabled if the back-end doesn't support non-stop debugging
		264	// TODO: Find a way to determine if non-stop is supported (i.e. find the GDB version) then grey out the check box if necessary
		265	// Button fNonStopButton = ControlFactory.createCheckBox(subComp, LaunchUIMessages.getString( "GDBDebuggerPage.15") ); //$NON-NLS-1$
		266	fNonStopCheckBox = ControlFactory.createCheckBox(subComp, LaunchUIMessages.getString("GDBDebuggerPage.13")); //$NON-NLS-1$
		267	fNonStopCheckBox.setEnabled(false);
		268	fNonStopCheckBox.addSelectionListener( new SelectionAdapter() {
		269	@Override
		270	public void widgetSelected(SelectionEvent e) {
		271	updateLaunchConfigurationDialog();
		272	}
		273	});
		274
245	label = ControlFactory.createLabel(subComp, LaunchUIMessages.getString("GDBDebuggerPage.9"), //$NON-NLS-1$	275	label = ControlFactory.createLabel(subComp, LaunchUIMessages.getString("GDBDebuggerPage.9"), //$NON-NLS-1$
246	200, SWT.DEFAULT, SWT.WRAP);	276	200, SWT.DEFAULT, SWT.WRAP);
		277
247	gd = new GridData(GridData.FILL_HORIZONTAL);	278	gd = new GridData(GridData.FILL_HORIZONTAL);
248	gd.horizontalSpan = 3;	279	gd.horizontalSpan = 3;
249	gd.widthHint = 200;	280	gd.widthHint = 200;

Lines 24-29 Link Here

(-)src/org/eclipse/dd/gdb/internal/ui/launching/LaunchUIMessages.properties (+1 lines)
24	GDBDebuggerPage.10=Shared Libraries	24	GDBDebuggerPage.10=Shared Libraries
25	GDBDebuggerPage.11=Protocol:	25	GDBDebuggerPage.11=Protocol:
26	GDBDebuggerPage.12=Default	26	GDBDebuggerPage.12=Default
		27	GDBDebuggerPage.13=Non-stop mode (Note: Requires non-stop GDB)
27	StandardGDBDebuggerPage.0=Debugger executable must be specified.	28	StandardGDBDebuggerPage.0=Debugger executable must be specified.
28	StandardGDBDebuggerPage.1=GDB Debugger Options	29	StandardGDBDebuggerPage.1=GDB Debugger Options
29	StandardGDBDebuggerPage.2=Main	30	StandardGDBDebuggerPage.2=Main




import org.eclipse.dd.dsf.service.DsfSession;
import org.eclipse.dd.gdb.internal.provisional.breakpoints.CBreakpointGdbThreadsFilterExtension;
import org.eclipse.dd.gdb.internal.provisional.launching.GdbLaunch;
import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl;
import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl.GDBThreadData;
import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;
import org.eclipse.dd.gdb.internal.ui.GdbUIPlugin;
import org.eclipse.dd.mi.service.IMIExecutionDMContext;

                    return;
                }

                ServiceTracker tracker = new ServiceTracker(GdbUIPlugin.getBundleContext(), IGDBRunControl.class
                    .getName(), null);
                tracker.open();
                IGDBRunControl runControl = (IGDBRunControl) tracker.getService();
                if (runControl != null) {
                    runControl.getThreadData((IMIExecutionDMContext) thread, new DataRequestMonitor<GDBThreadData>(
                        ImmediateExecutor.getInstance(), rm) {

Return to bug 237556

Added Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/service/IGDBRunControl.java (+70 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2008 Wind River Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Wind River Systems - initial API and implementation
10	* Ericsson - Modified for additional functionality
11	*******************************************************************************/
12	package org.eclipse.dd.gdb.internal.provisional.service;
13
14	import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
15	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControlDMContext;
16	import org.eclipse.dd.mi.service.IMIExecutionDMContext;
17	import org.eclipse.dd.mi.service.IMIRunControl;
18
19	/**
20	* This interface provides access to controlling and monitoring the execution
21	* state of a process being debugged. This interface does not actually
22	* provide methods for creating or destroying execution contexts, it doesn't
23	* even have methods for getting labels. That's because it is expected that
24	* higher level services, ones that deal with processes, kernels, or target
25	* features will provide that functionality.
26	*/
27	public interface IGDBRunControl extends IMIRunControl
28	{
29	/**
30	* Implement a custom execution data for threads in order to provide additional
31	* information. This object can be made separate from IExecutionDMData after
32	* the deprecated method: IDMService.getModelData() is no longer used.
33	*/
34	public static class GDBThreadData {
35	private final String fId;
36	private final String fName;
37
38	GDBThreadData(String id, String name) {
39	fId = id;
40	fName = name;
41	}
42
43	public String getName() {
44	return fName;
45	}
46	public String getId() { return fId; }
47
48	public boolean isDebuggerAttached() { return true; }
49	}
50
51	/**
52	* Implement a custom execution data the process in order to provide additional
53	* information. This object can be made separate from IExecutionDMData after
54	* the deprecated method: IDMService.getModelData() is no longer used.
55	*/
56	public static class GDBProcessData {
57	private final String fName;
58
59	GDBProcessData(String name) {
60	fName = name;
61	}
62
63	public String getName() {
64	return fName;
65	}
66	}
67
68	public void getProcessData(GDBControlDMContext gdbDmc, DataRequestMonitor<GDBProcessData> rm);
69	public void getThreadData(final IMIExecutionDMContext execDmc, final DataRequestMonitor<GDBThreadData> dataRequestMonitor);
70	}

Added Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/service/GdbDebugServicesFactoryNS.java (+33 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Ericsson and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Ericsson - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.dd.gdb.internal.provisional.service;
12
13	import org.eclipse.dd.dsf.debug.service.IRunControl;
14	import org.eclipse.dd.dsf.debug.service.IStack;
15	import org.eclipse.dd.dsf.service.DsfSession;
16	import org.eclipse.dd.mi.service.MIStackNS;
17
18	public class GdbDebugServicesFactoryNS extends GdbDebugServicesFactory {
19
20	public GdbDebugServicesFactoryNS(String version) {
21	super(version);
22	}
23
24	@Override
25	protected IStack createStackService(DsfSession session) {
26	return new MIStackNS(session);
27	}
28
29	@Override
30	protected IRunControl createRunControlService(DsfSession session) {
31	return new GDBRunControlNS(session);
32	}
33	}

Lines 14-24 Link Here

(-)src/org/eclipse/dd/mi/service/command/commands/MIExecStep.java (-2 / +16 lines)
14	package org.eclipse.dd.mi.service.command.commands;	14	package org.eclipse.dd.mi.service.command.commands;
15		15
16	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;	16	import org.eclipse.dd.dsf.debug.service.IRunControl.IExecutionDMContext;
		17	import org.eclipse.dd.mi.service.IMIExecutionDMContext;
17	import org.eclipse.dd.mi.service.command.output.MIInfo;	18	import org.eclipse.dd.mi.service.command.output.MIInfo;
18		19
19	/**	20	/**
20	*	21	*
21	* -exec-step	22	* -exec-step [--thread <tid>] [count]
22	*	23	*
23	* Asynchronous command. Resumes execution of the inferior program,	24	* Asynchronous command. Resumes execution of the inferior program,
24	* stopping when the beginning of the next source line is reached, if the	25	* stopping when the beginning of the next source line is reached, if the
Lines 29-38 Link Here
29	public class MIExecStep extends MICommand<MIInfo>	30	public class MIExecStep extends MICommand<MIInfo>
30	{	31	{
31	public MIExecStep(IExecutionDMContext dmc) {	32	public MIExecStep(IExecutionDMContext dmc) {
32	super(dmc, "-exec-step"); //$NON-NLS-1$	33	this(dmc, 1);
33	}	34	}
34		35
35	public MIExecStep(IExecutionDMContext dmc, int count) {	36	public MIExecStep(IExecutionDMContext dmc, int count) {
36	super(dmc, "-exec-step", new String[] { Integer.toString(count) }); //$NON-NLS-1$	37	super(dmc, "-exec-step", new String[] { Integer.toString(count) }); //$NON-NLS-1$
37	}	38	}
		39
		40	public MIExecStep(IMIExecutionDMContext dmc, boolean setThread) {
		41	this(dmc, setThread, 1);
		42	}
		43
		44	public MIExecStep(IMIExecutionDMContext dmc, boolean setThread, int count) {
		45	super(dmc, "-exec-step"); //$NON-NLS-1$
		46	if (setThread) {
		47	setParameters(new String[] { "--thread", Integer.toString(dmc.getThreadId()), Integer.toString(count) }); //$NON-NLS-1$
		48	} else {
		49	setParameters(new String[] { Integer.toString(count) });
		50	}
		51	}
38	}	52	}

Lines 20-26 Link Here

(-)src/org/eclipse/dd/mi/service/command/commands/MIStackListArguments.java (-17 / +18 lines)
20		20
21	/**	21	/**
22	*	22	*
23	* -stack-list-arguments SHOW-VALUES	23	* -stack-list-arguments [--thread <tid>] SHOW-VALUES
24	* [ LOW-FRAME HIGH-FRAME ]	24	* [ LOW-FRAME HIGH-FRAME ]
25	*	25	*
26	* Display a list of the arguments for the frames between LOW-FRAME and	26	* Display a list of the arguments for the frames between LOW-FRAME and
Lines 35-68 Link Here
35	public class MIStackListArguments extends MICommand<MIStackListArgumentsInfo>	35	public class MIStackListArguments extends MICommand<MIStackListArgumentsInfo>
36	{	36	{
37	public MIStackListArguments(IMIExecutionDMContext execDmc, boolean showValues) {	37	public MIStackListArguments(IMIExecutionDMContext execDmc, boolean showValues) {
		38	this(execDmc, false, showValues);
		39	}
		40
		41	public MIStackListArguments(IMIExecutionDMContext execDmc, boolean setThread, boolean showValues) {
38	super(execDmc, "-stack-list-arguments"); //$NON-NLS-1$	42	super(execDmc, "-stack-list-arguments"); //$NON-NLS-1$
39	if (showValues) {	43	if (setThread) {
40	setParameters(new String[]{"1"}); //$NON-NLS-1$	44	setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()), showValues ? "1" : "0" } ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
41	} else {	45	} else {
42	setParameters(new String[]{"0"}); //$NON-NLS-1$	46	setParameters(new String[] { showValues ? "1" : "0" } ); //$NON-NLS-1$ //$NON-NLS-2$
43	}	47	}
44	}	48	}
45		49
46	public MIStackListArguments(IFrameDMContext frameDmc, boolean showValues) {	50	public MIStackListArguments(IFrameDMContext frameDmc, boolean showValues) {
47	super(frameDmc, "-stack-list-arguments"); //$NON-NLS-1$	51	super(frameDmc, "-stack-list-arguments", new String[] { showValues ? "1" : "0" }); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
48	if (showValues) {
49	setParameters(new String[]{"1"}); //$NON-NLS-1$
50	} else {
51	setParameters(new String[]{"0"}); //$NON-NLS-1$
52	}
53	}	52	}
54		53
55	public MIStackListArguments(IMIExecutionDMContext execDmc, boolean showValues, int low, int high) {	54	public MIStackListArguments(IMIExecutionDMContext execDmc, boolean showValues, int low, int high) {
		55	this(execDmc, false, showValues, low, high);
		56	}
		57
		58	public MIStackListArguments(IMIExecutionDMContext execDmc, boolean setThread, boolean showValues, int low, int high) {
56	super(execDmc, "-stack-list-arguments"); //$NON-NLS-1$	59	super(execDmc, "-stack-list-arguments"); //$NON-NLS-1$
57	String[] params = new String[3];	60	if (setThread) {
58	if (showValues) {	61	setParameters(new String[] { "--thread", Integer.toString(execDmc.getThreadId()), //$NON-NLS-1$
59	params[0] = "1"; //$NON-NLS-1$	62	showValues ? "1" : "0", Integer.toString(low), Integer.toString(high) } ); //$NON-NLS-1$ //$NON-NLS-2$
60	} else {	63	} else {
61	params[0] = "0"; //$NON-NLS-1$	64	setParameters(new String[] {
		65	showValues ? "1" : "0", Integer.toString(low), Integer.toString(high) } ); //$NON-NLS-1$ //$NON-NLS-2$
62	}	66	}
63	params[1] = Integer.toString(low);
64	params[2] = Integer.toString(high);
65	setParameters(params);
66	}	67	}
67		68
68	@Override	69	@Override

Lines 67-77 Link Here

(-)src/org/eclipse/dd/mi/service/MIBreakpointsManager.java (-1 / +1 lines)
67	import org.eclipse.dd.dsf.service.DsfServiceEventHandler;	67	import org.eclipse.dd.dsf.service.DsfServiceEventHandler;
68	import org.eclipse.dd.dsf.service.DsfSession;	68	import org.eclipse.dd.dsf.service.DsfSession;
69	import org.eclipse.dd.mi.internal.MIPlugin;	69	import org.eclipse.dd.mi.internal.MIPlugin;
		70	import org.eclipse.dd.mi.service.IMIRunControl.MIExecutionDMC;
70	import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointAddedEvent;	71	import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointAddedEvent;
71	import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointRemovedEvent;	72	import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointRemovedEvent;
72	import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointUpdatedEvent;	73	import org.eclipse.dd.mi.service.MIBreakpoints.BreakpointUpdatedEvent;
73	import org.eclipse.dd.mi.service.MIBreakpoints.MIBreakpointDMContext;	74	import org.eclipse.dd.mi.service.MIBreakpoints.MIBreakpointDMContext;
74	import org.eclipse.dd.mi.service.MIRunControl.MIExecutionDMC;
75	import org.eclipse.dd.mi.service.breakpoint.actions.BreakpointActionAdapter;	75	import org.eclipse.dd.mi.service.breakpoint.actions.BreakpointActionAdapter;
76	import org.eclipse.dd.mi.service.command.events.MIBreakpointHitEvent;	76	import org.eclipse.dd.mi.service.command.events.MIBreakpointHitEvent;
77	import org.eclipse.dd.mi.service.command.events.MIGDBExitEvent;	77	import org.eclipse.dd.mi.service.command.events.MIGDBExitEvent;

Lines 70-76 Link Here

(-)src/org/eclipse/dd/mi/service/MIMemory.java (-4 / +4 lines)
70	}	70	}
71		71
72	@SuppressWarnings("unused")	72	@SuppressWarnings("unused")
73	private MIRunControl fRunControl;	73	private IMIRunControl fRunControl;
74	private MIMemoryCache fMemoryCache;	74	private MIMemoryCache fMemoryCache;
75		75
76	/**	76	/**
Lines 114-120 Link Here
114	register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());	114	register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());
115		115
116	// Get the RunControl so we can retrieve the current Execution context	116	// Get the RunControl so we can retrieve the current Execution context
117	fRunControl = getServicesTracker().getService(MIRunControl.class);	117	fRunControl = getServicesTracker().getService(IMIRunControl.class);
118		118
119	// Create the memory requests cache	119	// Create the memory requests cache
120	fMemoryCache = new MIMemoryCache();	120	fMemoryCache = new MIMemoryCache();
Lines 279-285 Link Here
279	//////////////////////////////////////////////////////////////////////////	279	//////////////////////////////////////////////////////////////////////////
280		280
281	@DsfServiceEventHandler	281	@DsfServiceEventHandler
282	public void eventDispatched(IRunControl.IResumedDMEvent e) {	282	public void eventDispatched(IRunControl.IContainerResumedDMEvent e) {
283	fMemoryCache.setTargetAvailable(e.getDMContext(), false);	283	fMemoryCache.setTargetAvailable(e.getDMContext(), false);
284	if (e.getReason() != StateChangeReason.STEP) {	284	if (e.getReason() != StateChangeReason.STEP) {
285	fMemoryCache.reset();	285	fMemoryCache.reset();
Lines 287-293 Link Here
287	}	287	}
288		288
289	@DsfServiceEventHandler	289	@DsfServiceEventHandler
290	public void eventDispatched(IRunControl.ISuspendedDMEvent e) {	290	public void eventDispatched(IRunControl.IContainerSuspendedDMEvent e) {
291	fMemoryCache.setTargetAvailable(e.getDMContext(), true);	291	fMemoryCache.setTargetAvailable(e.getDMContext(), true);
292	fMemoryCache.reset();	292	fMemoryCache.reset();
293	}	293	}

Lines 14-27 Link Here

(-)src/org/eclipse/dd/mi/service/MIRunControl.java (-203 / +3 lines)
14	import org.eclipse.core.runtime.IStatus;	14	import org.eclipse.core.runtime.IStatus;
15	import org.eclipse.core.runtime.Status;	15	import org.eclipse.core.runtime.Status;
16	import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;	16	import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
17	import org.eclipse.dd.dsf.concurrent.Immutable;
18	import org.eclipse.dd.dsf.concurrent.RequestMonitor;	17	import org.eclipse.dd.dsf.concurrent.RequestMonitor;
19	import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
20	import org.eclipse.dd.dsf.datamodel.AbstractDMEvent;
21	import org.eclipse.dd.dsf.datamodel.DMContexts;	18	import org.eclipse.dd.dsf.datamodel.DMContexts;
22	import org.eclipse.dd.dsf.datamodel.IDMContext;	19	import org.eclipse.dd.dsf.datamodel.IDMContext;
23	import org.eclipse.dd.dsf.datamodel.IDMEvent;	20	import org.eclipse.dd.dsf.datamodel.IDMEvent;
24	import org.eclipse.dd.dsf.debug.service.IRunControl;
25	import org.eclipse.dd.dsf.debug.service.IStack.IFrameDMContext;	21	import org.eclipse.dd.dsf.debug.service.IStack.IFrameDMContext;
26	import org.eclipse.dd.dsf.debug.service.command.CommandCache;	22	import org.eclipse.dd.dsf.debug.service.command.CommandCache;
27	import org.eclipse.dd.dsf.service.AbstractDsfService;	23	import org.eclipse.dd.dsf.service.AbstractDsfService;
Lines 38-56 Link Here
38	import org.eclipse.dd.mi.service.command.commands.MIExecStepInstruction;	34	import org.eclipse.dd.mi.service.command.commands.MIExecStepInstruction;
39	import org.eclipse.dd.mi.service.command.commands.MIExecUntil;	35	import org.eclipse.dd.mi.service.command.commands.MIExecUntil;
40	import org.eclipse.dd.mi.service.command.commands.MIThreadListIds;	36	import org.eclipse.dd.mi.service.command.commands.MIThreadListIds;
41	import org.eclipse.dd.mi.service.command.events.IMIDMEvent;
42	import org.eclipse.dd.mi.service.command.events.MIBreakpointHitEvent;
43	import org.eclipse.dd.mi.service.command.events.MIErrorEvent;
44	import org.eclipse.dd.mi.service.command.events.MIEvent;
45	import org.eclipse.dd.mi.service.command.events.MIGDBExitEvent;	37	import org.eclipse.dd.mi.service.command.events.MIGDBExitEvent;
46	import org.eclipse.dd.mi.service.command.events.MIRunningEvent;	38	import org.eclipse.dd.mi.service.command.events.MIRunningEvent;
47	import org.eclipse.dd.mi.service.command.events.MISharedLibEvent;
48	import org.eclipse.dd.mi.service.command.events.MISignalEvent;
49	import org.eclipse.dd.mi.service.command.events.MISteppingRangeEvent;
50	import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;	39	import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;
51	import org.eclipse.dd.mi.service.command.events.MIThreadCreatedEvent;	40	import org.eclipse.dd.mi.service.command.events.MIThreadCreatedEvent;
52	import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;	41	import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;
53	import org.eclipse.dd.mi.service.command.events.MIWatchpointTriggerEvent;
54	import org.eclipse.dd.mi.service.command.output.MIInfo;	42	import org.eclipse.dd.mi.service.command.output.MIInfo;
55	import org.eclipse.dd.mi.service.command.output.MIThreadListIdsInfo;	43	import org.eclipse.dd.mi.service.command.output.MIThreadListIdsInfo;
56	import org.osgi.framework.BundleContext;	44	import org.osgi.framework.BundleContext;
Lines 71-267 Link Here
71	* events and track service state, to be perfectly in sync with the service	59	* events and track service state, to be perfectly in sync with the service
72	* state.	60	* state.
73	*/	61	*/
74	public class MIRunControl extends AbstractDsfService implements IRunControl	62	public class MIRunControl extends AbstractDsfService implements IMIRunControl
75	{	63	{
76	protected class MIExecutionDMC extends AbstractDMContext	64	private AbstractMIControl fConnection;
77	implements IMIExecutionDMContext
78	{
79	/**
80	* Integer ID that is used to identify the thread in the GDB/MI protocol.
81	*/
82	private final int fThreadId;
83
84	/**
85	* Constructor for the context. It should not be called directly by clients.
86	* Instead clients should call {@link MIRunControl#createMIExecutionContext(IContainerDMContext, int)}
87	* to create instances of this context based on the thread ID.
88	* <p/>
89	* Classes extending {@link MIRunControl} may also extend this class to include
90	* additional information in the context.
91	*
92	* @param sessionId Session that this context belongs to.
93	* @param containerDmc The container that this context belongs to.
94	* @param threadId GDB/MI thread identifier.
95	*/
96	protected MIExecutionDMC(String sessionId, IContainerDMContext containerDmc, int threadId) {
97	super(sessionId, containerDmc != null ? new IDMContext[] { containerDmc } : new IDMContext[0]);
98	fThreadId = threadId;
99	}
100
101	/**
102	* Returns the GDB/MI thread identifier of this context.
103	* @return
104	*/
105	public int getThreadId(){
106	return fThreadId;
107	}
108
109	@Override
110	public String toString() { return baseToString() + ".thread[" + fThreadId + "]"; } //$NON-NLS-1$ //$NON-NLS-2$
111
112	@Override
113	public boolean equals(Object obj) {
114	return super.baseEquals(obj) && ((MIExecutionDMC)obj).fThreadId == fThreadId;
115	}
116
117	@Override
118	public int hashCode() { return super.baseHashCode() ^ fThreadId; }
119	}
120
121	@Immutable
122	private static class ExecutionData implements IExecutionDMData {
123	private final StateChangeReason fReason;
124	ExecutionData(StateChangeReason reason) {
125	fReason = reason;
126	}
127	public StateChangeReason getStateChangeReason() { return fReason; }
128	}
129
130	/**
131	* Base class for events generated by the MI Run Control service. Most events
132	* generated by the MI Run Control service are directly caused by some MI event.
133	* Other services may need access to the extended MI data carried in the event.
134	*
135	* @param <V> DMC that this event refers to
136	* @param <T> MIInfo object that is the direct cause of this event
137	* @see MIRunControl
138	*/
139	@Immutable
140	protected static class RunControlEvent<V extends IDMContext, T extends MIEvent<? extends IDMContext>> extends AbstractDMEvent<V>
141	implements IDMEvent<V>, IMIDMEvent
142	{
143	final private T fMIInfo;
144	public RunControlEvent(V dmc, T miInfo) {
145	super(dmc);
146	fMIInfo = miInfo;
147	}
148
149	public T getMIEvent() { return fMIInfo; }
150	}
151
152	/**
153	* Indicates that the given thread has been suspended.
154	*/
155	@Immutable
156	protected static class SuspendedEvent extends RunControlEvent<IExecutionDMContext, MIStoppedEvent>
157	implements ISuspendedDMEvent
158	{
159	SuspendedEvent(IExecutionDMContext ctx, MIStoppedEvent miInfo) {
160	super(ctx, miInfo);
161	}
162
163	public StateChangeReason getReason() {
164	if (getMIEvent() instanceof MIBreakpointHitEvent) {
165	return StateChangeReason.BREAKPOINT;
166	} else if (getMIEvent() instanceof MISteppingRangeEvent) {
167	return StateChangeReason.STEP;
168	} else if (getMIEvent() instanceof MISharedLibEvent) {
169	return StateChangeReason.SHAREDLIB;
170	}else if (getMIEvent() instanceof MISignalEvent) {
171	return StateChangeReason.SIGNAL;
172	}else if (getMIEvent() instanceof MIWatchpointTriggerEvent) {
173	return StateChangeReason.WATCHPOINT;
174	}else if (getMIEvent() instanceof MIErrorEvent) {
175	return StateChangeReason.ERROR;
176	}else {
177	return StateChangeReason.USER_REQUEST;
178	}
179	}
180	}
181
182	@Immutable
183	protected static class ContainerSuspendedEvent extends SuspendedEvent
184	implements IContainerSuspendedDMEvent
185	{
186	final IExecutionDMContext[] triggeringDmcs;
187	ContainerSuspendedEvent(IContainerDMContext containerDmc, MIStoppedEvent miInfo, IExecutionDMContext triggeringDmc) {
188	super(containerDmc, miInfo);
189	this.triggeringDmcs = triggeringDmc != null
190	? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
191	}
192
193	public IExecutionDMContext[] getTriggeringContexts() {
194	return triggeringDmcs;
195	}
196	}
197
198	@Immutable
199	protected static class ResumedEvent extends RunControlEvent<IExecutionDMContext, MIRunningEvent>
200	implements IResumedDMEvent
201	{
202	ResumedEvent(IExecutionDMContext ctx, MIRunningEvent miInfo) {
203	super(ctx, miInfo);
204	}
205
206	public StateChangeReason getReason() {
207	switch(getMIEvent().getType()) {
208	case MIRunningEvent.CONTINUE:
209	return StateChangeReason.USER_REQUEST;
210	case MIRunningEvent.NEXT:
211	case MIRunningEvent.NEXTI:
212	return StateChangeReason.STEP;
213	case MIRunningEvent.STEP:
214	case MIRunningEvent.STEPI:
215	return StateChangeReason.STEP;
216	case MIRunningEvent.FINISH:
217	return StateChangeReason.STEP;
218	case MIRunningEvent.UNTIL:
219	case MIRunningEvent.RETURN:
220	break;
221	}
222	return StateChangeReason.UNKNOWN;
223	}
224	}
225
226	@Immutable
227	protected static class ContainerResumedEvent extends ResumedEvent
228	implements IContainerResumedDMEvent
229	{
230	final IExecutionDMContext[] triggeringDmcs;
231
232	ContainerResumedEvent(IContainerDMContext containerDmc, MIRunningEvent miInfo, IExecutionDMContext triggeringDmc) {
233	super(containerDmc, miInfo);
234	this.triggeringDmcs = triggeringDmc != null
235	? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
236	}
237
238	public IExecutionDMContext[] getTriggeringContexts() {
239	return triggeringDmcs;
240	}
241	}
242
243	@Immutable
244	protected static class StartedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadCreatedEvent>
245	implements IStartedDMEvent
246	{
247	StartedDMEvent(IMIExecutionDMContext executionDmc, MIThreadCreatedEvent miInfo) {
248	super(executionDmc, miInfo);
249	}
250	}
251
252	@Immutable
253	protected static class ExitedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadExitEvent>
254	implements IExitedDMEvent
255	{
256	ExitedDMEvent(IMIExecutionDMContext executionDmc, MIThreadExitEvent miInfo) {
257	super(executionDmc, miInfo);
258	}
259	}
260
261	private AbstractMIControl fConnection;
262	private CommandCache fMICommandCache;	65	private CommandCache fMICommandCache;
263		66
264	// state flags	67	// State flags
265	private boolean fSuspended = true;	68	private boolean fSuspended = true;
266	private boolean fResumePending = false;	69	private boolean fResumePending = false;
267	private boolean fStepping = false;	70	private boolean fStepping = false;
Lines 291-299 Link Here
291	fMICommandCache = new CommandCache(getSession(), fConnection);	94	fMICommandCache = new CommandCache(getSession(), fConnection);
292	fMICommandCache.setContextAvailable(fConnection.getControlDMContext(), true);	95	fMICommandCache.setContextAvailable(fConnection.getControlDMContext(), true);
293	getSession().addServiceEventListener(this, null);	96	getSession().addServiceEventListener(this, null);
294
295	//register(new String[]{IRunControl.class.getName(), MIRunControl.class.getName()}, new Hashtable<String,String>());
296
297	rm.done();	97	rm.done();
298	}	98	}
299		99

Lines 57-63 Link Here

(-)src/org/eclipse/dd/mi/service/command/CLIEventProcessor.java (-26 / +9 lines)
57	// Last Thread ID created	57	// Last Thread ID created
58	private static int fLastThreadId;	58	private static int fLastThreadId;
59		59
60
61	public CLIEventProcessor(AbstractMIControl connection, IContainerDMContext containerDmc, MIInferiorProcess inferior) {	60	public CLIEventProcessor(AbstractMIControl connection, IContainerDMContext containerDmc, MIInferiorProcess inferior) {
62	fCommandControl = connection;	61	fCommandControl = connection;
63	fInferior = inferior;	62	fInferior = inferior;
Lines 109-140 Link Here
109	fEventList.add(oobr);	108	fEventList.add(oobr);
110		109
111	if (oobr instanceof MIConsoleStreamOutput) {	110	if (oobr instanceof MIConsoleStreamOutput) {
112	// Process Events of type DsfMIConsoleStreamOutput here	111	// Process Events of type DsfMIConsoleStreamOutput here
113	MIConsoleStreamOutput exec = (MIConsoleStreamOutput) oobr;	112	MIConsoleStreamOutput exec = (MIConsoleStreamOutput) oobr;
114		113
115	// Look for events with Pattern ^[New Thread 1077300144 (LWP 7973)	114	// Look for events with Pattern ^[New Thread 1077300144 (LWP 7973)
116	Pattern pattern = Pattern.compile("(^\\[New Thread.LWP\\s)(\\d*)", Pattern.MULTILINE); //$NON-NLS-1$	115	Pattern pattern = Pattern.compile("(^\\[New Thread.LWP\\s)(\\d*)", Pattern.MULTILINE); //$NON-NLS-1$
117	Matcher matcher = pattern.matcher(exec.getCString());	116	Matcher matcher = pattern.matcher(exec.getCString());
118	if (matcher.find()) {	117	if (matcher.find()) {
119	//fMapThreadIds.put(matcher.group(2), Integer.valueOf(++fLastThreadId));	118	MIEvent<?> e = new MIThreadCreatedEvent(fContainerDmc, ++fLastThreadId);
120	//DsfMIEvent e = new DsfMIThreadCreatedEvent(Integer.valueOf(matcher.group(2)));	119	fCommandControl.getSession().dispatchEvent(e, fCommandControl.getProperties());
121	MIEvent<?> e = new MIThreadCreatedEvent(fContainerDmc, ++fLastThreadId);	120	}
122	// Dispatch DsfMIThreadCreatedEvent
123	fCommandControl.getSession().dispatchEvent(e, fCommandControl.getProperties());
124	}
125	// HACK - For GDB thread exit events, we won't use the events generated by GDB. This event is
126	// raised in GDBRunControl class by polling and comparing the ExecutionContexts returned by
127	// -thread-list-ids command. This is done as threads reported by exit event are still reported till
128	// they completely exit the system.
129	// Look for Thread Exited Event with Pattern [Thread 1077300144 (LWP 23832) exited]\n
130	// See bug 200615 for details.
131	// pattern = Pattern.compile("(^\\[Thread.LWP\\s)(\\d)(.exited.$)", Pattern.MULTILINE); //$NON-NLS-1$
132	// matcher = pattern.matcher(exec.getCString());
133	// if (matcher.find()) {
134	// DsfMIEvent e = new DsfMIThreadExitEvent(fMapThreadIds.get(matcher.group(2)).intValue());
135	// // Dispatch DsfMIThreadExitEvent
136	// fConnection.getSession().dispatchEvent(e, fConnection.getProperties());
137	// }
138	}	121	}
139	}	122	}
140		123

Lines 28-47 Link Here

(-)src/org/eclipse/dd/mi/service/command/output/CLIInfoThreadsInfo.java (-7 / +7 lines)
28	*/	28	*/
29	public class CLIInfoThreadsInfo extends MIInfo {	29	public class CLIInfoThreadsInfo extends MIInfo {
30		30
31	protected List<ThreadInfo> info;	31	protected List<CLIThreadInfo> info;
32		32
33	public CLIInfoThreadsInfo(MIOutput out) {	33	public CLIInfoThreadsInfo(MIOutput out) {
34	super(out);	34	super(out);
35	parse();	35	parse();
36	}	36	}
37		37
38	public class ThreadInfo{	38	public class CLIThreadInfo{
39	String fName;	39	String fName;
40	String fGdbId;	40	String fGdbId;
41	String fPid;	41	String fPid;
42	boolean fIsCurrentThread = false;	42	boolean fIsCurrentThread = false;
43		43
44	public ThreadInfo(String tid, String pid, String name, boolean isCurrentThread)	44	public CLIThreadInfo(String tid, String pid, String name, boolean isCurrentThread)
45	{	45	{
46	this.fName = name;	46	this.fName = name;
47	this.fGdbId = tid;	47	this.fGdbId = tid;
Lines 56-67 Link Here
56	public boolean isCurrentThread(){return fIsCurrentThread; }	56	public boolean isCurrentThread(){return fIsCurrentThread; }
57	}	57	}
58		58
59	public List<ThreadInfo> getThreadInfo(){	59	public List<CLIThreadInfo> getThreadInfo(){
60	return info;	60	return info;
61	}	61	}
62		62
63	protected void parse() {	63	protected void parse() {
64	info = new ArrayList<ThreadInfo>();	64	info = new ArrayList<CLIThreadInfo>();
65	if (isDone()) {	65	if (isDone()) {
66	MIOutput out = getMIOutput();	66	MIOutput out = getMIOutput();
67	MIOOBRecord[] oobs = out.getMIOOBRecords();	67	MIOOBRecord[] oobs = out.getMIOOBRecords();
Lines 76-82 Link Here
76	}	76	}
77	}	77	}
78		78
79	protected void parseThreadInfo(String str, List<ThreadInfo> info) {	79	protected void parseThreadInfo(String str, List<CLIThreadInfo> info) {
80	// Fetch the OS ThreadId & Find the current thread	80	// Fetch the OS ThreadId & Find the current thread
81	if(str.length() > 0 ){	81	if(str.length() > 0 ){
82	Pattern pattern = Pattern.compile("(^\\?\\s\\d+)(\\sThread\\s)(0x[0-9a-fA-F]+\|-?\\d+)(\\s\\(LWP\\s)(\\d*)", Pattern.MULTILINE); //$NON-NLS-1$	82	Pattern pattern = Pattern.compile("(^\\?\\s\\d+)(\\sThread\\s)(0x[0-9a-fA-F]+\|-?\\d+)(\\s\\(LWP\\s)(\\d*)", Pattern.MULTILINE); //$NON-NLS-1$
Lines 88-94 Link Here
88	isCurrentThread = true;	88	isCurrentThread = true;
89	id = id.substring(1).trim();	89	id = id.substring(1).trim();
90	}	90	}
91	info.add(new ThreadInfo(id, matcher.group(5), "", isCurrentThread)); //$NON-NLS-1$	91	info.add(new CLIThreadInfo(id, matcher.group(5), "", isCurrentThread)); //$NON-NLS-1$
92	}	92	}
93	}	93	}
94	}	94	}

Added Link Here

(-)src/org/eclipse/dd/mi/service/IMIRunControl.java (+244 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2008 Wind River Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Wind River Systems - initial API and implementation
10	* Ericsson - Modified for additional functionality
11	*******************************************************************************/
12	package org.eclipse.dd.mi.service;
13
14	import org.eclipse.dd.dsf.concurrent.Immutable;
15	import org.eclipse.dd.dsf.datamodel.AbstractDMContext;
16	import org.eclipse.dd.dsf.datamodel.AbstractDMEvent;
17	import org.eclipse.dd.dsf.datamodel.IDMContext;
18	import org.eclipse.dd.dsf.datamodel.IDMEvent;
19	import org.eclipse.dd.dsf.debug.service.IRunControl;
20	import org.eclipse.dd.mi.service.command.events.IMIDMEvent;
21	import org.eclipse.dd.mi.service.command.events.MIBreakpointHitEvent;
22	import org.eclipse.dd.mi.service.command.events.MIErrorEvent;
23	import org.eclipse.dd.mi.service.command.events.MIEvent;
24	import org.eclipse.dd.mi.service.command.events.MIRunningEvent;
25	import org.eclipse.dd.mi.service.command.events.MISharedLibEvent;
26	import org.eclipse.dd.mi.service.command.events.MISignalEvent;
27	import org.eclipse.dd.mi.service.command.events.MISteppingRangeEvent;
28	import org.eclipse.dd.mi.service.command.events.MIStoppedEvent;
29	import org.eclipse.dd.mi.service.command.events.MIThreadCreatedEvent;
30	import org.eclipse.dd.mi.service.command.events.MIThreadExitEvent;
31	import org.eclipse.dd.mi.service.command.events.MIWatchpointTriggerEvent;
32
33	/**
34	* This interface provides access to controlling and monitoring the execution
35	* state of a process being debugged. This interface does not actually
36	* provide methods for creating or destroying execution contexts, it doesn't
37	* even have methods for getting labels. That's because it is expected that
38	* higher level services, ones that deal with processes, kernels, or target
39	* features will provide that functionality.
40	*/
41	public interface IMIRunControl extends IRunControl
42	{
43	class MIExecutionDMC extends AbstractDMContext implements IMIExecutionDMContext
44	{
45	/**
46	* Integer ID that is used to identify the thread in the GDB/MI protocol.
47	*/
48	private final int fThreadId;
49
50	/**
51	* Constructor for the context. It should not be called directly by clients.
52	* Instead clients should call {@link MIRunControl#createMIExecutionContext(IContainerDMContext, int)}
53	* to create instances of this context based on the thread ID.
54	* <p/>
55	* Classes extending {@link MIRunControl} may also extend this class to include
56	* additional information in the context.
57	*
58	* @param sessionId Session that this context belongs to.
59	* @param containerDmc The container that this context belongs to.
60	* @param threadId GDB/MI thread identifier.
61	*/
62	protected MIExecutionDMC(String sessionId, IContainerDMContext containerDmc, int threadId) {
63	super(sessionId, containerDmc != null ? new IDMContext[] { containerDmc } : new IDMContext[0]);
64	fThreadId = threadId;
65	}
66
67	/**
68	* Returns the GDB/MI thread identifier of this context.
69	* @return
70	*/
71	public int getThreadId(){
72	return fThreadId;
73	}
74
75	@Override
76	public String toString() { return baseToString() + ".thread[" + fThreadId + "]"; } //$NON-NLS-1$ //$NON-NLS-2$
77
78	@Override
79	public boolean equals(Object obj) {
80	return super.baseEquals(obj) && ((MIExecutionDMC)obj).fThreadId == fThreadId;
81	}
82
83	@Override
84	public int hashCode() { return super.baseHashCode() ^ fThreadId; }
85	}
86
87	@Immutable
88	static class ExecutionData implements IExecutionDMData {
89	private final StateChangeReason fReason;
90	ExecutionData(StateChangeReason reason) {
91	fReason = reason;
92	}
93	public StateChangeReason getStateChangeReason() { return fReason; }
94	}
95
96	/**
97	* Base class for events generated by the MI Run Control service. Most events
98	* generated by the MI Run Control service are directly caused by some MI event.
99	* Other services may need access to the extended MI data carried in the event.
100	*
101	* @param <V> DMC that this event refers to
102	* @param <T> MIInfo object that is the direct cause of this event
103	* @see MIRunControl
104	*/
105	@Immutable
106	static class RunControlEvent<V extends IDMContext, T extends MIEvent<? extends IDMContext>> extends AbstractDMEvent<V>
107	implements IDMEvent<V>, IMIDMEvent
108	{
109	final private T fMIInfo;
110	public RunControlEvent(V dmc, T miInfo) {
111	super(dmc);
112	fMIInfo = miInfo;
113	}
114
115	public T getMIEvent() { return fMIInfo; }
116	}
117
118	/**
119	* Indicates that the given thread has been suspended.
120	*/
121	@Immutable
122	static class SuspendedEvent extends RunControlEvent<IExecutionDMContext, MIStoppedEvent>
123	implements ISuspendedDMEvent
124	{
125	SuspendedEvent(IExecutionDMContext ctx, MIStoppedEvent miInfo) {
126	super(ctx, miInfo);
127	}
128
129	public StateChangeReason getReason() {
130	if (getMIEvent() instanceof MIBreakpointHitEvent) {
131	return StateChangeReason.BREAKPOINT;
132	} else if (getMIEvent() instanceof MISteppingRangeEvent) {
133	return StateChangeReason.STEP;
134	} else if (getMIEvent() instanceof MISharedLibEvent) {
135	return StateChangeReason.SHAREDLIB;
136	}else if (getMIEvent() instanceof MISignalEvent) {
137	return StateChangeReason.SIGNAL;
138	}else if (getMIEvent() instanceof MIWatchpointTriggerEvent) {
139	return StateChangeReason.WATCHPOINT;
140	}else if (getMIEvent() instanceof MIErrorEvent) {
141	return StateChangeReason.ERROR;
142	}else {
143	return StateChangeReason.USER_REQUEST;
144	}
145	}
146	}
147
148	@Immutable
149	static class ContainerSuspendedEvent extends SuspendedEvent
150	implements IContainerSuspendedDMEvent
151	{
152	final IExecutionDMContext[] triggeringDmcs;
153	ContainerSuspendedEvent(IContainerDMContext containerDmc, MIStoppedEvent miInfo, IExecutionDMContext triggeringDmc) {
154	super(containerDmc, miInfo);
155	this.triggeringDmcs = triggeringDmc != null
156	? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
157	}
158
159	public IExecutionDMContext[] getTriggeringContexts() {
160	return triggeringDmcs;
161	}
162	}
163
164	@Immutable
165	static class ThreadSuspendedEvent extends SuspendedEvent
166	{
167	ThreadSuspendedEvent(IExecutionDMContext executionDmc, MIStoppedEvent miInfo) {
168	super(executionDmc, miInfo);
169	}
170	}
171
172	@Immutable
173	static class ResumedEvent extends RunControlEvent<IExecutionDMContext, MIRunningEvent>
174	implements IResumedDMEvent
175	{
176	ResumedEvent(IExecutionDMContext ctx, MIRunningEvent miInfo) {
177	super(ctx, miInfo);
178	}
179
180	public StateChangeReason getReason() {
181	switch(getMIEvent().getType()) {
182	case MIRunningEvent.CONTINUE:
183	return StateChangeReason.USER_REQUEST;
184	case MIRunningEvent.NEXT:
185	case MIRunningEvent.NEXTI:
186	return StateChangeReason.STEP;
187	case MIRunningEvent.STEP:
188	case MIRunningEvent.STEPI:
189	return StateChangeReason.STEP;
190	case MIRunningEvent.FINISH:
191	return StateChangeReason.STEP;
192	case MIRunningEvent.UNTIL:
193	case MIRunningEvent.RETURN:
194	break;
195	}
196	return StateChangeReason.UNKNOWN;
197	}
198	}
199
200	@Immutable
201	static class ContainerResumedEvent extends ResumedEvent
202	implements IContainerResumedDMEvent
203	{
204	final IExecutionDMContext[] triggeringDmcs;
205
206	ContainerResumedEvent(IContainerDMContext containerDmc, MIRunningEvent miInfo, IExecutionDMContext triggeringDmc) {
207	super(containerDmc, miInfo);
208	this.triggeringDmcs = triggeringDmc != null
209	? new IExecutionDMContext[] { triggeringDmc } : new IExecutionDMContext[0];
210	}
211
212	public IExecutionDMContext[] getTriggeringContexts() {
213	return triggeringDmcs;
214	}
215	}
216
217	@Immutable
218	static class ThreadResumedEvent extends ResumedEvent
219	{
220	ThreadResumedEvent(IExecutionDMContext executionDmc, MIRunningEvent miInfo) {
221	super(executionDmc, miInfo);
222	}
223	}
224
225	@Immutable
226	static class StartedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadCreatedEvent>
227	implements IStartedDMEvent
228	{
229	StartedDMEvent(IMIExecutionDMContext executionDmc, MIThreadCreatedEvent miInfo) {
230	super(executionDmc, miInfo);
231	}
232	}
233
234	@Immutable
235	static class ExitedDMEvent extends RunControlEvent<IExecutionDMContext,MIThreadExitEvent>
236	implements IExitedDMEvent
237	{
238	ExitedDMEvent(IMIExecutionDMContext executionDmc, MIThreadExitEvent miInfo) {
239	super(executionDmc, miInfo);
240	}
241	}
242
243	public IMIExecutionDMContext createMIExecutionContext(IContainerDMContext container, int threadId);
244	}

Added Link Here

(-)src/org/eclipse/dd/mi/service/command/output/MIThreadInfoInfo.java (+254 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 QNX Software Systems and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* QNX Software Systems - Initial API and implementation
10	* Ericsson AB - Modified for DSF Reference Implementation
11	*******************************************************************************/
12	package org.eclipse.dd.mi.service.command.output;
13
14	import java.math.BigInteger;
15	import java.util.List;
16	import java.util.Vector;
17	import java.util.regex.Matcher;
18	import java.util.regex.Pattern;
19
20	import org.eclipse.dd.dsf.concurrent.Immutable;
21
22	/**
23	* GDB/MI thread list parsing.
24	*
25	* Example 1:
26	*
27	* -thread-info
28	* ^done,threads=[
29	* {id="2",target-id="Thread 0xb7c8ab90 (LWP 7010)",
30	* frame={level="0",addr="0x08048bba",func="my_func",args=[{name="arg",value="0xbff056f5"}],
31	* file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="26"},
32	* running="0"},
33	* {id="1",target-id="Thread 0xb7c8b8d0 (LWP 7007)",
34	* frame={level="0",addr="0x08048a77",func="timer",args=[{name="duration",value="0xbff056f5 \"10\""}],
35	* file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="39"},
36	* running="0"}
37	* ],current-thread-id="2"
38	*
39
40	* Example 2:
41	*
42	* -thread-info 2
43	* ^done,threads=[
44	* {id="2",target-id="Thread 0xb7c8ab90 (LWP 7010)",
45	* frame={level="0",addr="0x08048bba",func="my_func",args=[{name="arg",value="0xbff056f5"}],
46	* file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="26"},
47	* running="0"}
48	* ]
49	*
50	*
51	* Example 3 (non-stop):
52	*
53	* -thread-info
54	* ^done,threads=[
55	* {id="2",target-id="Thread 0xb7c8eb90 (LWP 7807)",running="1"},
56	* {id="1",target-id="Thread 0xb7c8b8d0 (LWP 7007)",
57	* frame={level="0",addr="0x08048a77",func="timer",args=[{name="duration",value="0xbff056f5 \"10\""}],
58	* file="my_test.cc",fullname="/home/francois/GDB/my_test.cc",line="39"},
59	* running="0"}
60	* ],current-thread-id="1"
61	*/
62	public class MIThreadInfoInfo extends MIInfo {
63
64	@Immutable
65	public class ThreadInfo {
66
67	final private String fGdbId;
68	final private String fTargetId;
69	final private String fOsId;
70	final private ThreadFrame fTopFrame;
71	final private boolean fIsRunning;
72
73	public ThreadInfo(String gdbId, String targetId, String osId, ThreadFrame topFrame, boolean isRunning) {
74	fGdbId = gdbId;
75	fTargetId = targetId;
76	fOsId = osId;
77	fTopFrame = topFrame;
78	fIsRunning = isRunning;
79	}
80
81	public String getGdbId() { return fGdbId; }
82	public String getTargetId() { return fTargetId; }
83	public String getOsId() { return fOsId; }
84	public ThreadFrame getTopFrame() { return fTopFrame; }
85	public boolean isRunning() { return fIsRunning; }
86	}
87
88	@Immutable
89	public class ThreadFrame {
90	final private int fStackLevel;
91	final private BigInteger fAddress;
92	final private String fFunction;
93	final private ThreadFrameFunctionArgs[] fArgs;
94	final private String fFileName;
95	final private String fFullName;
96	final private int fLineNumber;
97
98	public ThreadFrame(int stackLevel, BigInteger address, String function,
99	ThreadFrameFunctionArgs[] args, String file, String fullName, int line)
100	{
101	fStackLevel = stackLevel;
102	fAddress = address;
103	fFunction = function;
104	fArgs = args;
105	fFileName = file;
106	fFullName = fullName;
107	fLineNumber = line;
108	}
109
110	public int getStackLevel() { return fStackLevel; }
111	public BigInteger getAddress() { return fAddress; }
112	public String getFucntion() { return fFunction; }
113	public ThreadFrameFunctionArgs[] getArgs() { return fArgs; }
114	public String getFileName() { return fFileName; }
115	public String getFullName() { return fFullName; }
116	public int getLineNumber() { return fLineNumber; }
117	}
118
119	@Immutable
120	public class ThreadFrameFunctionArgs {
121	}
122
123	private int fCurrentThread = -1;
124	private List<ThreadInfo> fThreadInfoList = null;
125	private int[] fThreadList = null;
126
127	public MIThreadInfoInfo(MIOutput out) {
128	super(out);
129	parse();
130	}
131
132	public int getCurrentThread() {
133	return fCurrentThread;
134	}
135
136	public List<ThreadInfo> getThreadInfoList() {
137	return fThreadInfoList;
138	}
139
140	public int[] getThreadList() {
141	return fThreadList;
142	}
143
144	// General format:
145	// threads=[{...}],current-thread-id="n"
146	private void parse() {
147	if (isDone()) {
148	MIOutput out = getMIOutput();
149	MIResultRecord rr = out.getMIResultRecord();
150	if (rr != null) {
151	MIResult[] results = rr.getMIResults();
152	for (int i = 0; i < results.length; i++) {
153	String var = results[i].getVariable();
154	if (var.equals("threads")) { //$NON-NLS-1$
155	MIValue val = results[i].getMIValue();
156	if (val instanceof MIList) {
157	parseThreads((MIList) val);
158	}
159	}
160	else if (var.equals("current-thread-id")) { //$NON-NLS-1$
161	MIValue value = results[i].getMIValue();
162	if (value instanceof MIConst) {
163	String str = ((MIConst) value).getCString();
164	try {
165	fCurrentThread = Integer.parseInt(str.trim());
166	} catch (NumberFormatException e) {
167	fCurrentThread = -1;
168	}
169	}
170	}
171	}
172	}
173	}
174	if (fThreadInfoList == null) {
175	fThreadInfoList = new Vector<ThreadInfo>(0);
176	fThreadList = new int[0];
177	}
178	}
179
180	// General formats:
181	// id="n",target-id="Thread 0xb7c8ab90 (LWP 7010)",frame={...},running="0"
182	// id="n",target-id="Thread 0xb7c8eb90 (LWP 7807)",running="1"
183	private void parseThreads(MIList list) {
184	MIValue[] values = list.getMIValues();
185	fThreadInfoList = new Vector<ThreadInfo>(values.length);
186	fThreadList = new int[values.length];
187
188	for (int i = 0; i < values.length; i++) {
189	MITuple value = (MITuple) values[i];
190	MIResult[] results = value.getMIResults();
191
192	String gdbId = null;
193	String targetId = null;
194	String osId = null;
195	ThreadFrame topFrame = null;
196	boolean isRunning = false;
197
198	for (int j = 0; j < results.length; j++) {
199	MIResult result = results[j];
200	String var = result.getVariable();
201	if (var.equals("id")) { //$NON-NLS-1$
202	MIValue val = results[j].getMIValue();
203	if (val instanceof MIConst) {
204	gdbId = ((MIConst) val).getCString();
205	}
206	}
207	else if (var.equals("target-id")) { //$NON-NLS-1$
208	MIValue val = results[j].getMIValue();
209	if (val instanceof MIConst) {
210	targetId = ((MIConst) val).getCString();
211	osId = parseOsId(targetId);
212	}
213	}
214	else if (var.equals("frame")) { //$NON-NLS-1$
215	MIValue val = results[j].getMIValue();
216	topFrame = parseFrame(val);
217	}
218	else if (var.equals("running")) { //$NON-NLS-1$
219	MIValue val = results[j].getMIValue();
220	if (val instanceof MIConst) {
221	String v = ((MIConst) val).getCString();
222	isRunning = v.equals("1"); //$NON-NLS-1$
223	}
224	}
225	}
226
227	fThreadInfoList.add(new ThreadInfo(gdbId, targetId, osId, topFrame, isRunning));
228	try {
229	fThreadList[i] = Integer.parseInt(gdbId);
230	} catch (NumberFormatException e) {
231	}
232	}
233	}
234
235	// General format:
236	// "Thread 0xb7c8ab90 (LWP 7010)"
237	private String parseOsId(String str) {
238	Pattern pattern = Pattern.compile("(Thread\\s)(0x[0-9a-fA-F]+\|-?\\d+)(\\s\\(LWP\\s)(\\d)", 0); //$NON-NLS-1$
239	Matcher matcher = pattern.matcher(str);
240	if (matcher.find()) {
241	return matcher.group(4);
242	}
243	return null;
244	}
245
246	// General format:
247	// level="0",addr="0x08048bba",func="func",args=[...],file="file.cc",fullname="/path/file.cc",line="26"
248	private ThreadFrame parseFrame(MIValue val) {
249	// TODO Auto-generated method stub
250	return null;
251	}
252
253	}
254

Lines 20-27 Link Here

(-)src/org/eclipse/dd/gdb/internal/ui/viewmodel/launch/ThreadVMNode.java (-4 / +4 lines)
20	import org.eclipse.dd.dsf.ui.concurrent.ViewerDataRequestMonitor;	20	import org.eclipse.dd.dsf.ui.concurrent.ViewerDataRequestMonitor;
21	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.AbstractDMVMProvider;	21	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.AbstractDMVMProvider;
22	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.IDMVMContext;	22	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.IDMVMContext;
23	import org.eclipse.dd.gdb.internal.provisional.service.GDBRunControl;	23	import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl;
24	import org.eclipse.dd.gdb.internal.provisional.service.GDBRunControl.GDBThreadData;	24	import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl.GDBThreadData;
25	import org.eclipse.dd.mi.service.IMIExecutionDMContext;	25	import org.eclipse.dd.mi.service.IMIExecutionDMContext;
26	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementCompareRequest;	26	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementCompareRequest;
27	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementLabelProvider;	27	import org.eclipse.debug.internal.ui.viewers.model.provisional.IElementLabelProvider;
Lines 49-55 Link Here
49	@Override	49	@Override
50	protected void updateLabelInSessionThread(ILabelUpdate[] updates) {	50	protected void updateLabelInSessionThread(ILabelUpdate[] updates) {
51	for (final ILabelUpdate update : updates) {	51	for (final ILabelUpdate update : updates) {
52	final GDBRunControl runControl = getServicesTracker().getService(GDBRunControl.class);	52	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
53	if ( runControl == null ) {	53	if ( runControl == null ) {
54	handleFailedUpdate(update);	54	handleFailedUpdate(update);
55	continue;	55	continue;
Lines 78-84 Link Here
78		78
79	// We're in a new dispatch cycle, and we have to check whether the	79	// We're in a new dispatch cycle, and we have to check whether the
80	// service reference is still valid.	80	// service reference is still valid.
81	final GDBRunControl runControl = getServicesTracker().getService(GDBRunControl.class);	81	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
82	if ( runControl == null ) {	82	if ( runControl == null ) {
83	handleFailedUpdate(update);	83	handleFailedUpdate(update);
84	return;	84	return;

Lines 25-32 Link Here

(-)src/org/eclipse/dd/gdb/internal/ui/viewmodel/launch/ContainerVMNode.java (-5 / +5 lines)
25	import org.eclipse.dd.dsf.ui.viewmodel.VMDelta;	25	import org.eclipse.dd.dsf.ui.viewmodel.VMDelta;
26	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.AbstractDMVMProvider;	26	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.AbstractDMVMProvider;
27	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.IDMVMContext;	27	import org.eclipse.dd.dsf.ui.viewmodel.datamodel.IDMVMContext;
28	import org.eclipse.dd.gdb.internal.provisional.service.GDBRunControl;	28	import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl;
29	import org.eclipse.dd.gdb.internal.provisional.service.GDBRunControl.GDBProcessData;	29	import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl.GDBProcessData;
30	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;	30	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;
31	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControlDMContext;	31	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControlDMContext;
32	import org.eclipse.dd.mi.service.command.MIInferiorProcess;	32	import org.eclipse.dd.mi.service.command.MIInferiorProcess;
Lines 72-78 Link Here
72		72
73	@Override	73	@Override
74	protected void updateLabelInSessionThread(final ILabelUpdate update) {	74	protected void updateLabelInSessionThread(final ILabelUpdate update) {
75	final GDBRunControl runControl = getServicesTracker().getService(GDBRunControl.class);	75	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
76	if ( runControl == null ) {	76	if ( runControl == null ) {
77	handleFailedUpdate(update);	77	handleFailedUpdate(update);
78	return;	78	return;
Lines 151-157 Link Here
151	try {	151	try {
152	getSession().getExecutor().execute(new DsfRunnable() {	152	getSession().getExecutor().execute(new DsfRunnable() {
153	public void run() {	153	public void run() {
154	final GDBRunControl runControl = getServicesTracker().getService(GDBRunControl.class);	154	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
155	if ( runControl != null ) {	155	if ( runControl != null ) {
156	runControl.getProcessData(	156	runControl.getProcessData(
157	procDmc,	157	procDmc,
Lines 203-209 Link Here
203	try {	203	try {
204	getSession().getExecutor().execute(new DsfRunnable() {	204	getSession().getExecutor().execute(new DsfRunnable() {
205	public void run() {	205	public void run() {
206	final GDBRunControl runControl = getServicesTracker().getService(GDBRunControl.class);	206	final IGDBRunControl runControl = getServicesTracker().getService(IGDBRunControl.class);
207	if ( runControl != null ) {	207	if ( runControl != null ) {
208	runControl.getProcessData(	208	runControl.getProcessData(
209	procDmc,	209	procDmc,

Lines 30-37 Link Here

(-)src/org/eclipse/dd/gdb/internal/ui/breakpoints/GdbThreadFilterEditor.java (-4 / +4 lines)
30	import org.eclipse.dd.dsf.service.DsfSession;	30	import org.eclipse.dd.dsf.service.DsfSession;
31	import org.eclipse.dd.gdb.internal.provisional.breakpoints.CBreakpointGdbThreadsFilterExtension;	31	import org.eclipse.dd.gdb.internal.provisional.breakpoints.CBreakpointGdbThreadsFilterExtension;
32	import org.eclipse.dd.gdb.internal.provisional.launching.GdbLaunch;	32	import org.eclipse.dd.gdb.internal.provisional.launching.GdbLaunch;
33	import org.eclipse.dd.gdb.internal.provisional.service.GDBRunControl;	33	import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl;
34	import org.eclipse.dd.gdb.internal.provisional.service.GDBRunControl.GDBThreadData;	34	import org.eclipse.dd.gdb.internal.provisional.service.IGDBRunControl.GDBThreadData;
35	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;	35	import org.eclipse.dd.gdb.internal.provisional.service.command.GDBControl;
36	import org.eclipse.dd.gdb.internal.ui.GdbUIPlugin;	36	import org.eclipse.dd.gdb.internal.ui.GdbUIPlugin;
37	import org.eclipse.dd.mi.service.IMIExecutionDMContext;	37	import org.eclipse.dd.mi.service.IMIExecutionDMContext;
Lines 493-502 Link Here
493	return;	493	return;
494	}	494	}
495		495
496	ServiceTracker tracker = new ServiceTracker(GdbUIPlugin.getBundleContext(), GDBRunControl.class	496	ServiceTracker tracker = new ServiceTracker(GdbUIPlugin.getBundleContext(), IGDBRunControl.class
497	.getName(), null);	497	.getName(), null);
498	tracker.open();	498	tracker.open();
499	GDBRunControl runControl = (GDBRunControl) tracker.getService();	499	IGDBRunControl runControl = (IGDBRunControl) tracker.getService();
500	if (runControl != null) {	500	if (runControl != null) {
501	runControl.getThreadData((IMIExecutionDMContext) thread, new DataRequestMonitor<GDBThreadData>(	501	runControl.getThreadData((IMIExecutionDMContext) thread, new DataRequestMonitor<GDBThreadData>(
502	ImmediateExecutor.getInstance(), rm) {	502	ImmediateExecutor.getInstance(), rm) {