Attachment #114481 for bug #248636

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




 *******************************************************************************/
package org.eclipse.dd.mi.service;

import java.util.Hashtable;
import java.util.LinkedList;
import java.util.ListIterator;


     */
    private void doInitialize(final RequestMonitor requestMonitor) {

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

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

    @Override
    public void shutdown(final RequestMonitor requestMonitor) {

//    	// Unregister this service
//        unregister();

		// Remove event listener
    	getSession().removeServiceEventListener(this);

        return MIPlugin.getBundleContext();
    }

    /**
	 * @since 1.1
	 */
    protected CommandCache getCommandCache() { return fMemoryCache.fCommandCache; }

    /**
	 * @since 1.1
	 */
    protected void setMemoryCache(MIMemoryCache cache) { fMemoryCache = cache; }

    
    ///////////////////////////////////////////////////////////////////////////
    // IMemory
    ///////////////////////////////////////////////////////////////////////////

	// MIMemoryCache
	///////////////////////////////////////////////////////////////////////////

	/**
	 * @since 1.1
	 */
	protected class MIMemoryCache {

		// Back-end commands cache
		private CommandCache fCommandCache;

	    * @param count
	    * @param drm
	    */
	   protected void readMemoryBlock(IDMContext dmc, IAddress address, final long offset,
	    	final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)
	    {
	    	/* To simplify the parsing of the MI result, we request the output to

	    	Character asChar = null;

	    	fCommandCache.execute(
	    		new MIDataReadMemory(dmc, offset, address.toString(), mode, word_size, nb_rows, nb_cols, asChar),
	    		new DataRequestMonitor<MIDataReadMemoryInfo>(getExecutor(), drm) {
	    			@Override
	    			protected void handleSuccess() {

		 * @param buffer
		 * @param rm
		 */
	   protected void writeMemoryBlock(final IDMContext dmc, final IAddress address, final long offset,
			final int word_size, final int count, final byte[] buffer, final RequestMonitor rm)
	    {
	    	// Each byte is written individually (GDB power...)

	        for (int i = 0; i < count; i++) {
	        	String value = new Byte(buffer[i]).toString();
	        	fCommandCache.execute(
	            		new MIDataWriteMemory(dmc, offset + i, baseAddress, format, word_size, value),
	            		new DataRequestMonitor<MIDataWriteMemoryInfo>(getExecutor(), countingRM)
	            	);
	    	}




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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.IStatus;

 * 
 */
public class GDBProcesses_7_0 extends AbstractDsfService 
    implements IGDBProcesses, ICachingService, IEventListener {

	// Below is the context hierarchy that is implemented between the
	// MIProcesses service and the MIRunControl service for the MI 

		// Register this service.
		register(new String[] { IProcesses.class.getName(),
				IMIProcesses.class.getName(),
				IGDBProcesses.class.getName(),
				GDBProcesses_7_0.class.getName() },
				new Hashtable<String, String>());
        

    	return createContainerContext(processDmc, groupId);
    }

    public IMIExecutionDMContext[] getExecutionContexts(IMIContainerDMContext containerDmc) {
    	String groupId = containerDmc.getGroupId();
    	List<IMIExecutionDMContext> execDmcList = new ArrayList<IMIExecutionDMContext>(); 
    	Iterator<Map.Entry<String, String>> iterator = fThreadToGroupMap.entrySet().iterator();
    	while (iterator.hasNext()){
    		Map.Entry<String, String> entry = iterator.next();
    		if (entry.getValue().equals(groupId)) {
    			String threadId = entry.getKey();
    			IProcessDMContext procDmc = DMContexts.getAncestorOfType(containerDmc, IProcessDMContext.class);
    			IMIExecutionDMContext execDmc = createExecutionContext(containerDmc, 
    																   createThreadContext(procDmc, threadId),
    																   threadId);
    			execDmcList.add(execDmc);
    		}
    	}
    	return execDmcList.toArray(new IMIExecutionDMContext[0]);
    }

	/**
	 * This method obtains the model data for a given IThreadDMContext object
	 * which can represent a thread or a process.




import org.eclipse.dd.mi.service.MIBreakpoints;
import org.eclipse.dd.mi.service.MIBreakpointsManager;
import org.eclipse.dd.mi.service.MIDisassembly;
import org.eclipse.dd.mi.service.MIMemory;
import org.eclipse.dd.mi.service.MIModules;
import org.eclipse.dd.mi.service.MIRegisters;
import org.eclipse.dd.mi.service.MIStack;


	@Override
	protected IMemory createMemoryService(DsfSession session) {
		if ("6.8".compareTo(fVersion) < 0) { //$NON-NLS-1$
			return new GDBMemory_7_0(session);
		}

		return new GDBMemory(session);
	}

	@Override




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

import java.util.Hashtable;

import org.eclipse.dd.dsf.concurrent.RequestMonitor;
import org.eclipse.dd.dsf.debug.service.IMemory;
import org.eclipse.dd.dsf.service.DsfSession;
import org.eclipse.dd.mi.service.MIMemory;

public class GDBMemory extends MIMemory {

	public GDBMemory(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) {
		register(new String[] { MIMemory.class.getName(), IMemory.class.getName(), GDBMemory.class.getName()}, 
				new Hashtable<String, String>());
		requestMonitor.done();
	}

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


}




/*******************************************************************************
 * 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.mi.service.IMIContainerDMContext;
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
import org.eclipse.dd.mi.service.IMIProcesses;

public interface IGDBProcesses extends IMIProcesses {
    /**
     * Get a list of all execution contexts belonging to a container.  This call is synchronous,
     * unlike the call to getProcessesBeingDebugged().  However, some services may not be able
     * to fulfill this request synchronously and will have to rely on getProcessesBeingDebugged().
     *
     * @param containerDmc The container for which we want to get the execution contexts
     */
    IMIExecutionDMContext[] getExecutionContexts(IMIContainerDMContext containerDmc);

}




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

import java.util.Hashtable;

import org.eclipse.cdt.core.IAddress;
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.debug.service.IMemory;
import org.eclipse.dd.dsf.service.DsfSession;
import org.eclipse.dd.mi.service.IMIContainerDMContext;
import org.eclipse.dd.mi.service.IMIExecutionDMContext;
import org.eclipse.dd.mi.service.MIMemory;
import org.eclipse.debug.core.model.MemoryByte;

public class GDBMemory_7_0 extends MIMemory {

	public GDBMemory_7_0(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) {
		register(new String[] { MIMemory.class.getName(), IMemory.class.getName(), GDBMemory_7_0.class.getName()}, 
				new Hashtable<String, String>());

		setMemoryCache(new GDBMemoryCache());

		requestMonitor.done();
	}

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

	protected class GDBMemoryCache extends MIMemoryCache {
		@Override
		protected void readMemoryBlock(IDMContext dmc, IAddress address, final long offset,
				final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)
		{
			IDMContext threadOrMemoryDmc = dmc;

			IMIContainerDMContext containerCtx = DMContexts.getAncestorOfType(dmc, IMIContainerDMContext.class);
			if(containerCtx != null) {
				IGDBProcesses procService = getServicesTracker().getService(IGDBProcesses.class);

				if (procService != null) {
					IMIExecutionDMContext[] execCtxs = procService.getExecutionContexts(containerCtx);
					// Return any thread... let's take the first one.
					if (execCtxs != null && execCtxs.length > 0) {
						threadOrMemoryDmc = execCtxs[0];
					}
				}
			}
			
			super.readMemoryBlock(threadOrMemoryDmc, address, offset, word_size, count, drm);
		}

		/**
		 * @param memoryDMC
		 * @param address
		 * @param offset
		 * @param word_size
		 * @param count
		 * @param buffer
		 * @param rm
		 */
		@Override
		protected void writeMemoryBlock(final IDMContext dmc, final IAddress address, final long offset,
				final int word_size, final int count, final byte[] buffer, final RequestMonitor rm)
		{
			IDMContext threadOrMemoryDmc = dmc;

			IMIContainerDMContext containerCtx = DMContexts.getAncestorOfType(dmc, IMIContainerDMContext.class);
			if(containerCtx != null) {
				IGDBProcesses procService = getServicesTracker().getService(IGDBProcesses.class);

				if (procService != null) {
					IMIExecutionDMContext[] execCtxs = procService.getExecutionContexts(containerCtx);
					// Return any thread... let's take the first one.
					if (execCtxs != null && execCtxs.length > 0) {
						threadOrMemoryDmc = execCtxs[0];
					}
				}
			}

			super.writeMemoryBlock(threadOrMemoryDmc, address, offset, word_size, count, buffer, rm);
		}
	}

}

Return to bug 248636

Lines 13-19 Link Here

(-)src/org/eclipse/dd/mi/service/MIMemory.java (-10 / +23 lines)
13	*******************************************************************************/	13	*******************************************************************************/
14	package org.eclipse.dd.mi.service;	14	package org.eclipse.dd.mi.service;
15		15
16	import java.util.Hashtable;
17	import java.util.LinkedList;	16	import java.util.LinkedList;
18	import java.util.ListIterator;	17	import java.util.ListIterator;
19		18
Lines 112-119 Link Here
112	*/	111	*/
113	private void doInitialize(final RequestMonitor requestMonitor) {	112	private void doInitialize(final RequestMonitor requestMonitor) {
114		113
115	// Register this service	114	// // Register this service
116	register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());	115	// register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());
117		116
118	// Create the memory requests cache	117	// Create the memory requests cache
119	fMemoryCache = new MIMemoryCache();	118	fMemoryCache = new MIMemoryCache();
Lines 131-138 Link Here
131	@Override	130	@Override
132	public void shutdown(final RequestMonitor requestMonitor) {	131	public void shutdown(final RequestMonitor requestMonitor) {
133		132
134	// Unregister this service	133	// // Unregister this service
135	unregister();	134	// unregister();
136		135
137	// Remove event listener	136	// Remove event listener
138	getSession().removeServiceEventListener(this);	137	getSession().removeServiceEventListener(this);
Lines 149-154 Link Here
149	return MIPlugin.getBundleContext();	148	return MIPlugin.getBundleContext();
150	}	149	}
151		150
		151	/**
		152	* @since 1.1
		153	*/
		154	protected CommandCache getCommandCache() { return fMemoryCache.fCommandCache; }
		155
		156	/**
		157	* @since 1.1
		158	*/
		159	protected void setMemoryCache(MIMemoryCache cache) { fMemoryCache = cache; }
		160
		161
152	///////////////////////////////////////////////////////////////////////////	162	///////////////////////////////////////////////////////////////////////////
153	// IMemory	163	// IMemory
154	///////////////////////////////////////////////////////////////////////////	164	///////////////////////////////////////////////////////////////////////////
Lines 440-446 Link Here
440	// MIMemoryCache	450	// MIMemoryCache
441	///////////////////////////////////////////////////////////////////////////	451	///////////////////////////////////////////////////////////////////////////
442		452
443	private class MIMemoryCache {	453	/**
		454	* @since 1.1
		455	*/
		456	protected class MIMemoryCache {
444		457
445	// Back-end commands cache	458	// Back-end commands cache
446	private CommandCache fCommandCache;	459	private CommandCache fCommandCache;
Lines 848-854 Link Here
848	* @param count	861	* @param count
849	* @param drm	862	* @param drm
850	*/	863	*/
851	private void readMemoryBlock(IMemoryDMContext memoryDMC, IAddress address, final long offset,	864	protected void readMemoryBlock(IDMContext dmc, IAddress address, final long offset,
852	final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)	865	final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)
853	{	866	{
854	/* To simplify the parsing of the MI result, we request the output to	867	/* To simplify the parsing of the MI result, we request the output to
Lines 860-866 Link Here
860	Character asChar = null;	873	Character asChar = null;
861		874
862	fCommandCache.execute(	875	fCommandCache.execute(
863	new MIDataReadMemory(memoryDMC, offset, address.toString(), mode, word_size, nb_rows, nb_cols, asChar),	876	new MIDataReadMemory(dmc, offset, address.toString(), mode, word_size, nb_rows, nb_cols, asChar),
864	new DataRequestMonitor<MIDataReadMemoryInfo>(getExecutor(), drm) {	877	new DataRequestMonitor<MIDataReadMemoryInfo>(getExecutor(), drm) {
865	@Override	878	@Override
866	protected void handleSuccess() {	879	protected void handleSuccess() {
Lines 890-896 Link Here
890	* @param buffer	903	* @param buffer
891	* @param rm	904	* @param rm
892	*/	905	*/
893	private void writeMemoryBlock(final IMemoryDMContext memoryDMC, final IAddress address, final long offset,	906	protected void writeMemoryBlock(final IDMContext dmc, final IAddress address, final long offset,
894	final int word_size, final int count, final byte[] buffer, final RequestMonitor rm)	907	final int word_size, final int count, final byte[] buffer, final RequestMonitor rm)
895	{	908	{
896	// Each byte is written individually (GDB power...)	909	// Each byte is written individually (GDB power...)
Lines 906-912 Link Here
906	for (int i = 0; i < count; i++) {	919	for (int i = 0; i < count; i++) {
907	String value = new Byte(buffer[i]).toString();	920	String value = new Byte(buffer[i]).toString();
908	fCommandCache.execute(	921	fCommandCache.execute(
909	new MIDataWriteMemory(memoryDMC, offset + i, baseAddress, format, word_size, value),	922	new MIDataWriteMemory(dmc, offset + i, baseAddress, format, word_size, value),
910	new DataRequestMonitor<MIDataWriteMemoryInfo>(getExecutor(), countingRM)	923	new DataRequestMonitor<MIDataWriteMemoryInfo>(getExecutor(), countingRM)
911	);	924	);
912	}	925	}

Lines 10-18 Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/service/GDBProcesses_7_0.java (-1 / +22 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.dd.gdb.internal.provisional.service;	11	package org.eclipse.dd.gdb.internal.provisional.service;
12		12
		13	import java.util.ArrayList;
13	import java.util.HashMap;	14	import java.util.HashMap;
14	import java.util.Hashtable;	15	import java.util.Hashtable;
15	import java.util.Iterator;	16	import java.util.Iterator;
		17	import java.util.List;
16	import java.util.Map;	18	import java.util.Map;
17		19
18	import org.eclipse.core.runtime.IStatus;	20	import org.eclipse.core.runtime.IStatus;
Lines 75-81 Link Here
75	*	77	*
76	*/	78	*/
77	public class GDBProcesses_7_0 extends AbstractDsfService	79	public class GDBProcesses_7_0 extends AbstractDsfService
78	implements IMIProcesses, ICachingService, IEventListener {	80	implements IGDBProcesses, ICachingService, IEventListener {
79		81
80	// Below is the context hierarchy that is implemented between the	82	// Below is the context hierarchy that is implemented between the
81	// MIProcesses service and the MIRunControl service for the MI	83	// MIProcesses service and the MIRunControl service for the MI
Lines 393-398 Link Here
393	// Register this service.	395	// Register this service.
394	register(new String[] { IProcesses.class.getName(),	396	register(new String[] { IProcesses.class.getName(),
395	IMIProcesses.class.getName(),	397	IMIProcesses.class.getName(),
		398	IGDBProcesses.class.getName(),
396	GDBProcesses_7_0.class.getName() },	399	GDBProcesses_7_0.class.getName() },
397	new Hashtable<String, String>());	400	new Hashtable<String, String>());
398		401
Lines 448-453 Link Here
448	return createContainerContext(processDmc, groupId);	451	return createContainerContext(processDmc, groupId);
449	}	452	}
450		453
		454	public IMIExecutionDMContext[] getExecutionContexts(IMIContainerDMContext containerDmc) {
		455	String groupId = containerDmc.getGroupId();
		456	List<IMIExecutionDMContext> execDmcList = new ArrayList<IMIExecutionDMContext>();
		457	Iterator<Map.Entry<String, String>> iterator = fThreadToGroupMap.entrySet().iterator();
		458	while (iterator.hasNext()){
		459	Map.Entry<String, String> entry = iterator.next();
		460	if (entry.getValue().equals(groupId)) {
		461	String threadId = entry.getKey();
		462	IProcessDMContext procDmc = DMContexts.getAncestorOfType(containerDmc, IProcessDMContext.class);
		463	IMIExecutionDMContext execDmc = createExecutionContext(containerDmc,
		464	createThreadContext(procDmc, threadId),
		465	threadId);
		466	execDmcList.add(execDmc);
		467	}
		468	}
		469	return execDmcList.toArray(new IMIExecutionDMContext[0]);
		470	}
		471
451	/**	472	/**
452	* This method obtains the model data for a given IThreadDMContext object	473	* This method obtains the model data for a given IThreadDMContext object
453	* which can represent a thread or a process.	474	* which can represent a thread or a process.

Lines 31-37 Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/service/GdbDebugServicesFactory.java (-2 / +5 lines)
31	import org.eclipse.dd.mi.service.MIBreakpoints;	31	import org.eclipse.dd.mi.service.MIBreakpoints;
32	import org.eclipse.dd.mi.service.MIBreakpointsManager;	32	import org.eclipse.dd.mi.service.MIBreakpointsManager;
33	import org.eclipse.dd.mi.service.MIDisassembly;	33	import org.eclipse.dd.mi.service.MIDisassembly;
34	import org.eclipse.dd.mi.service.MIMemory;
35	import org.eclipse.dd.mi.service.MIModules;	34	import org.eclipse.dd.mi.service.MIModules;
36	import org.eclipse.dd.mi.service.MIRegisters;	35	import org.eclipse.dd.mi.service.MIRegisters;
37	import org.eclipse.dd.mi.service.MIStack;	36	import org.eclipse.dd.mi.service.MIStack;
Lines 92-98 Link Here
92		91
93	@Override	92	@Override
94	protected IMemory createMemoryService(DsfSession session) {	93	protected IMemory createMemoryService(DsfSession session) {
95	return new MIMemory(session);	94	if ("6.8".compareTo(fVersion) < 0) { //$NON-NLS-1$
		95	return new GDBMemory_7_0(session);
		96	}
		97
		98	return new GDBMemory(session);
96	}	99	}
97		100
98	@Override	101	@Override

Added Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/service/GDBMemory_7_0.java (+103 lines)
1	package org.eclipse.dd.gdb.internal.provisional.service;
2
3	import java.util.Hashtable;
4
5	import org.eclipse.cdt.core.IAddress;
6	import org.eclipse.dd.dsf.concurrent.DataRequestMonitor;
7	import org.eclipse.dd.dsf.concurrent.RequestMonitor;
8	import org.eclipse.dd.dsf.datamodel.DMContexts;
9	import org.eclipse.dd.dsf.datamodel.IDMContext;
10	import org.eclipse.dd.dsf.debug.service.IMemory;
11	import org.eclipse.dd.dsf.service.DsfSession;
12	import org.eclipse.dd.mi.service.IMIContainerDMContext;
13	import org.eclipse.dd.mi.service.IMIExecutionDMContext;
14	import org.eclipse.dd.mi.service.MIMemory;
15	import org.eclipse.debug.core.model.MemoryByte;
16
17	public class GDBMemory_7_0 extends MIMemory {
18
19	public GDBMemory_7_0(DsfSession session) {
20	super(session);
21	}
22
23	@Override
24	public void initialize(final RequestMonitor requestMonitor) {
25	super.initialize(
26	new RequestMonitor(getExecutor(), requestMonitor) {
27	@Override
28	public void handleSuccess() {
29	doInitialize(requestMonitor);
30	}});
31	}
32
33	private void doInitialize(final RequestMonitor requestMonitor) {
34	register(new String[] { MIMemory.class.getName(), IMemory.class.getName(), GDBMemory_7_0.class.getName()},
35	new Hashtable<String, String>());
36
37	setMemoryCache(new GDBMemoryCache());
38
39	requestMonitor.done();
40	}
41
42	@Override
43	public void shutdown(final RequestMonitor requestMonitor) {
44	unregister();
45	super.shutdown(requestMonitor);
46	}
47
48	protected class GDBMemoryCache extends MIMemoryCache {
49	@Override
50	protected void readMemoryBlock(IDMContext dmc, IAddress address, final long offset,
51	final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)
52	{
53	IDMContext threadOrMemoryDmc = dmc;
54
55	IMIContainerDMContext containerCtx = DMContexts.getAncestorOfType(dmc, IMIContainerDMContext.class);
56	if(containerCtx != null) {
57	IGDBProcesses procService = getServicesTracker().getService(IGDBProcesses.class);
58
59	if (procService != null) {
60	IMIExecutionDMContext[] execCtxs = procService.getExecutionContexts(containerCtx);
61	// Return any thread... let's take the first one.
62	if (execCtxs != null && execCtxs.length > 0) {
63	threadOrMemoryDmc = execCtxs[0];
64	}
65	}
66	}
67
68	super.readMemoryBlock(threadOrMemoryDmc, address, offset, word_size, count, drm);
69	}
70
71	/**
72	* @param memoryDMC
73	* @param address
74	* @param offset
75	* @param word_size
76	* @param count
77	* @param buffer
78	* @param rm
79	*/
80	@Override
81	protected void writeMemoryBlock(final IDMContext dmc, final IAddress address, final long offset,
82	final int word_size, final int count, final byte[] buffer, final RequestMonitor rm)
83	{
84	IDMContext threadOrMemoryDmc = dmc;
85
86	IMIContainerDMContext containerCtx = DMContexts.getAncestorOfType(dmc, IMIContainerDMContext.class);
87	if(containerCtx != null) {
88	IGDBProcesses procService = getServicesTracker().getService(IGDBProcesses.class);
89
90	if (procService != null) {
91	IMIExecutionDMContext[] execCtxs = procService.getExecutionContexts(containerCtx);
92	// Return any thread... let's take the first one.
93	if (execCtxs != null && execCtxs.length > 0) {
94	threadOrMemoryDmc = execCtxs[0];
95	}
96	}
97	}
98
99	super.writeMemoryBlock(threadOrMemoryDmc, address, offset, word_size, count, buffer, rm);
100	}
101	}
102
103	}

Added Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/service/IGDBProcesses.java (+27 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.mi.service.IMIContainerDMContext;
14	import org.eclipse.dd.mi.service.IMIExecutionDMContext;
15	import org.eclipse.dd.mi.service.IMIProcesses;
16
17	public interface IGDBProcesses extends IMIProcesses {
18	/**
19	* Get a list of all execution contexts belonging to a container. This call is synchronous,
20	* unlike the call to getProcessesBeingDebugged(). However, some services may not be able
21	* to fulfill this request synchronously and will have to rely on getProcessesBeingDebugged().
22	*
23	* @param containerDmc The container for which we want to get the execution contexts
24	*/
25	IMIExecutionDMContext[] getExecutionContexts(IMIContainerDMContext containerDmc);
26
27	}