Attachment #114708 for bug #248636

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

Lines 116-122 Link Here

(-)src/org/eclipse/dd/mi/service/MIMemory.java (-6 / +20 lines)
116	register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());	116	register(new String[] { MIMemory.class.getName(), IMemory.class.getName() }, new Hashtable<String, String>());
117		117
118	// Create the memory requests cache	118	// Create the memory requests cache
119	fMemoryCache = new MIMemoryCache();	119	setMemoryCache(new MIMemoryCache());
120		120
121	// Register as service event listener	121	// Register as service event listener
122	getSession().addServiceEventListener(this, null);	122	getSession().addServiceEventListener(this, null);
Lines 149-154 Link Here
149	return MIPlugin.getBundleContext();	149	return MIPlugin.getBundleContext();
150	}	150	}
151		151
		152	/**
		153	* This method resets the memory cache. It allows an overriding class to provide
		154	* its own memory cache class.
		155	*
		156	* @since 1.1
		157	*/
		158	protected void setMemoryCache(MIMemoryCache cache) { fMemoryCache = cache; }
		159
		160
152	///////////////////////////////////////////////////////////////////////////	161	///////////////////////////////////////////////////////////////////////////
153	// IMemory	162	// IMemory
154	///////////////////////////////////////////////////////////////////////////	163	///////////////////////////////////////////////////////////////////////////
Lines 440-446 Link Here
440	// MIMemoryCache	449	// MIMemoryCache
441	///////////////////////////////////////////////////////////////////////////	450	///////////////////////////////////////////////////////////////////////////
442		451
443	private class MIMemoryCache {	452	/**
		453	* This class can now be overridden.
		454	*
		455	* @since 1.1
		456	*/
		457	protected class MIMemoryCache {
444		458
445	// Back-end commands cache	459	// Back-end commands cache
446	private CommandCache fCommandCache;	460	private CommandCache fCommandCache;
Lines 848-854 Link Here
848	* @param count	862	* @param count
849	* @param drm	863	* @param drm
850	*/	864	*/
851	private void readMemoryBlock(IMemoryDMContext memoryDMC, IAddress address, final long offset,	865	protected void readMemoryBlock(IDMContext dmc, IAddress address, final long offset,
852	final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)	866	final int word_size, final int count, final DataRequestMonitor<MemoryByte[]> drm)
853	{	867	{
854	/* To simplify the parsing of the MI result, we request the output to	868	/* To simplify the parsing of the MI result, we request the output to
Lines 860-866 Link Here
860	Character asChar = null;	874	Character asChar = null;
861		875
862	fCommandCache.execute(	876	fCommandCache.execute(
863	new MIDataReadMemory(memoryDMC, offset, address.toString(), mode, word_size, nb_rows, nb_cols, asChar),	877	new MIDataReadMemory(dmc, offset, address.toString(), mode, word_size, nb_rows, nb_cols, asChar),
864	new DataRequestMonitor<MIDataReadMemoryInfo>(getExecutor(), drm) {	878	new DataRequestMonitor<MIDataReadMemoryInfo>(getExecutor(), drm) {
865	@Override	879	@Override
866	protected void handleSuccess() {	880	protected void handleSuccess() {
Lines 890-896 Link Here
890	* @param buffer	904	* @param buffer
891	* @param rm	905	* @param rm
892	*/	906	*/
893	private void writeMemoryBlock(final IMemoryDMContext memoryDMC, final IAddress address, final long offset,	907	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)	908	final int word_size, final int count, final byte[] buffer, final RequestMonitor rm)
895	{	909	{
896	// Each byte is written individually (GDB power...)	910	// Each byte is written individually (GDB power...)
Lines 906-912 Link Here
906	for (int i = 0; i < count; i++) {	920	for (int i = 0; i < count; i++) {
907	String value = new Byte(buffer[i]).toString();	921	String value = new Byte(buffer[i]).toString();
908	fCommandCache.execute(	922	fCommandCache.execute(
909	new MIDataWriteMemory(memoryDMC, offset + i, baseAddress, format, word_size, value),	923	new MIDataWriteMemory(dmc, offset + i, baseAddress, format, word_size, value),
910	new DataRequestMonitor<MIDataWriteMemoryInfo>(getExecutor(), countingRM)	924	new DataRequestMonitor<MIDataWriteMemoryInfo>(getExecutor(), countingRM)
911	);	925	);
912	}	926	}




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

Lines 92-97 Link Here

(-)src/org/eclipse/dd/gdb/internal/provisional/service/GdbDebugServicesFactory.java (+4 lines)
92		92
93	@Override	93	@Override
94	protected IMemory createMemoryService(DsfSession session) {	94	protected IMemory createMemoryService(DsfSession session) {
		95	if ("6.8".compareTo(fVersion) < 0) { //$NON-NLS-1$
		96	return new GDBMemory_7_0(session);
		97	}
		98
95	return new MIMemory(session);	99	return new MIMemory(session);
96	}	100	}
97		101




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

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	}