Attachment #202690 for bug #355833

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

Lines 3-9 Link Here

(-)a/dsf-gdb/org.eclipse.cdt.dsf.gdb.ui/META-INF/MANIFEST.MF (-1 / +1 lines)
3	Bundle-Name: %pluginName	3	Bundle-Name: %pluginName
4	Bundle-Vendor: %providerName	4	Bundle-Vendor: %providerName
5	Bundle-SymbolicName: org.eclipse.cdt.dsf.gdb.ui;singleton:=true	5	Bundle-SymbolicName: org.eclipse.cdt.dsf.gdb.ui;singleton:=true
6	Bundle-Version: 2.2.0.qualifier	6	Bundle-Version: 2.2.1.qualifier
7	Bundle-Activator: org.eclipse.cdt.dsf.gdb.internal.ui.GdbUIPlugin	7	Bundle-Activator: org.eclipse.cdt.dsf.gdb.internal.ui.GdbUIPlugin
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Require-Bundle: org.eclipse.ui,	9	Require-Bundle: org.eclipse.ui,

Lines 11-17 Link Here

(-)a/dsf-gdb/org.eclipse.cdt.dsf.gdb.ui/pom.xml (-1 / +1 lines)
11	<relativePath>../../pom.xml</relativePath>	11	<relativePath>../../pom.xml</relativePath>
12	</parent>	12	</parent>
13		13
14	<version>2.2.0-SNAPSHOT</version>	14	<version>2.2.1-SNAPSHOT</version>
15	<artifactId>org.eclipse.cdt.dsf.gdb.ui</artifactId>	15	<artifactId>org.eclipse.cdt.dsf.gdb.ui</artifactId>
16	<packaging>eclipse-plugin</packaging>	16	<packaging>eclipse-plugin</packaging>
17	</project>	17	</project>




     * a thread filter in a given thread, that thread should be checked.
     */
    protected void setInitialCheckedState() {
    	CBreakpointGdbThreadsFilterExtension filterExtension = fPage.getFilterExtension();
        try {
            IContainerDMContext[] targets = filterExtension.getTargetFilters();

            // TODO: Hack to properly initialize the target/thread list
            // Should be done in filterExtension.initialize() but we don't know
            // how to get the target list from an ICBreakpoint...
            if (targets.length == 0) {
            	targets = getDebugTargets();
            	for (IContainerDMContext target : targets) {
            		filterExtension.setTargetFilter(target);
            	}
            }
            // TODO: End of hack

            for (int i = 0; i < targets.length; i++) {
                IExecutionDMContext[] filteredThreads = filterExtension.getThreadFilters(targets[i]);
                if (filteredThreads != null) {
                    for (int j = 0; j < filteredThreads.length; ++j) {
                    	// Mark this thread as selected
                        fCheckHandler.checkThread(filteredThreads[j], true);
                    }
                } else {
                	// Mark the entire process as selected
                    fCheckHandler.checkTarget(targets[i], true);
                }
            }

    }

    protected void doStore() {
    	CBreakpointGdbThreadsFilterExtension filterExtension = fPage.getFilterExtension();
        IContainerDMContext[] targets = getDebugTargets();
        for (int i = 0; i < targets.length; ++i) {
            try {

Lines 1-5 Link Here

(-)a/dsf-gdb/org.eclipse.cdt.dsf.gdb/src/org/eclipse/cdt/dsf/gdb/breakpoints/CBreakpointGdbThreadsFilterExtension.java (-3 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 Wind River Systems and others.	2	* Copyright (c) 2007, 2011 Wind River Systems and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 35-42 Link Here
35	* @see org.eclipse.cdt.debug.core.model.ICBreakpointExtension#initialize(org.eclipse.cdt.debug.core.model.ICBreakpoint)	35	* @see org.eclipse.cdt.debug.core.model.ICBreakpointExtension#initialize(org.eclipse.cdt.debug.core.model.ICBreakpoint)
36	*/	36	*/
37	public void initialize(ICBreakpoint breakpoint) {	37	public void initialize(ICBreakpoint breakpoint) {
38	// TODO: Initialize fFilteredThreadsByTarget with current IContainerDMContext[]
39	// TODO: IRunControl?
40	}	38	}
41		39
42	/* (non-Javadoc)	40	/* (non-Javadoc)




/*******************************************************************************
 * Copyright (c) 2007, 2011 Wind River 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

 *     Ericsson   - Added breakpoint filter support
 *     Ericsson   - Re-factored the service and put a few comments
 *     Ericsson   - Added Action support
 *     Marc Khouzam (Ericsson) - Fix support for thread filter (Bug 355833)
 *******************************************************************************/

package org.eclipse.cdt.dsf.mi.service;

            // Upon determining the debuggerPath, the breakpoint is installed
            determineDebuggerPath(dmc, attributes, new RequestMonitor(getExecutor(), countingRm) {
                @Override
                protected void handleSuccess() {                	
                	// Before installing a breakpoint, set the target filter for that target.
                	// Even if the breakpoint is disabled when we start, the target filter 
                	// can be accessed by the user through the breakpoint properties UI, so
                	// we must set it right now.
                	// This is the reason we don't do this in 'installBreakpoint', which is not
                	// called right away if the breakpoint is disabled.
                	try {
                		IContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IContainerDMContext.class);
                		IDsfBreakpointExtension filterExt = getFilterExtension(breakpoint);
                		if (filterExt.getThreadFilters(containerDmc) == null) {
                			// Do this only if there wasn't already an entry, or else we would
                			// erase the content of that previous entry.
                			filterExt.setTargetFilter(containerDmc);
                		}
					} catch (CoreException e) {
					}
                	
                	// Install only if the breakpoint is enabled at startup (Bug261082)
                    // Note that Tracepoints are not affected by "skip-all"
                	boolean bpEnabled = attributes.get(ICBreakpoint.ENABLED).equals(true) &&

        final Map<ICBreakpoint, Set<String>> threadsIDs = fBreakpointThreads.get(dmc);
        assert threadsIDs != null;

        // Remove any target filter (if any)
        try {
        	IContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IContainerDMContext.class);
        	getFilterExtension(breakpoint).removeTargetFilter(containerDmc);
        }
        catch( CoreException e ) {
        }
        
        // Remove breakpoint problem marker (if any)
        removeBreakpointProblemMarker(breakpoint);


                                    new RequestMonitor(getExecutor(), countingRm) {
                                    @Override
                                    protected void handleSuccess() {
                                    	// For a new breakpoint, set the target filter.
                                    	try {
                                    		IContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IContainerDMContext.class);
                                    		IDsfBreakpointExtension filterExt = getFilterExtension((ICBreakpoint)breakpoint);
                                    		if (filterExt.getThreadFilters(containerDmc) == null) {
                                    			// Do this only if there wasn't already an entry, or else we would
                                    			// erase the content of that previous entry.
                                    			filterExt.setTargetFilter(containerDmc);
                                    		}
                    					} catch (CoreException e) {
                    					}
                                    	
                                        installBreakpoint(dmc, (ICBreakpoint) breakpoint,
                                            attrs, countingRm);
                                    }

    	for (IBreakpointsTargetDMContext ctx : fPlatformBPs.keySet()) {
    		Map<ICBreakpoint, Map<String, Object>> breakpoints = fPlatformBPs.get(ctx);
            clearBreakpointStatus(breakpoints.keySet().toArray(new ICBreakpoint[breakpoints.size()]), ctx);
            
            // Also clear any target filter since we will not be calling uninstallBreakpoint() which
            // usually does that work.
            IContainerDMContext dmc = DMContexts.getAncestorOfType(ctx, IContainerDMContext.class);
            clearTargetFilter(dmc, breakpoints.keySet());
    	}
    	// This will prevent Shutdown() from trying to remove bps from a
    	// backend that has already shutdown
        fPlatformBPs.clear();
    }

    private void clearTargetFilter(IContainerDMContext containerDmc, Set<ICBreakpoint> breakpoints) {
        // Remove any target filter (if any)
        try {
        	for (ICBreakpoint bp : breakpoints) {
        		getFilterExtension(bp).removeTargetFilter(containerDmc);
        	}
        }
        catch( CoreException e ) {
        }
    }


    /**
     * @param bps

     * @return
     */
    private Set<String> extractThreads(IBreakpointsTargetDMContext context, ICBreakpoint breakpoint) {
    	Set<String> results = new HashSet<String>();
    	
    	IExecutionDMContext[] threads = null;
    	try {
    		IContainerDMContext containerDmc = DMContexts.getAncestorOfType(context, IContainerDMContext.class);
			threads = getFilterExtension(breakpoint).getThreadFilters(containerDmc);
		} catch (CoreException e) {
		}

    	if (threads == null || threads.length == 0) {
            results.add("0"); //$NON-NLS-1$    
            return results;
        try {
            // Retrieve the targets
            IDsfBreakpointExtension filterExtension = getFilterExtension(breakpoint);
            IContainerDMContext[] targets = filterExtension.getTargetFilters();

            // If no target is present, breakpoint applies to all.
            if (targets.length == 0) {
                results.add("0"); //$NON-NLS-1$    
                return results;
            }

            // Extract the thread IDs (if there is none, we are covered)
            for (IContainerDMContext ctxt : targets) {
                if (ctxt.equals(context) || DMContexts.isAncestorOf(ctxt, context)) {
                    threads.add(filterExtension.getThreadFilters(ctxt));
                }
            }
        } catch (CoreException e1) {
        }
    	
        if (supportsThreads(breakpoint)) {
            for (IExecutionDMContext thread : threads) {
            	if (thread instanceof IMIExecutionDMContext) {
            		results.add(Integer.toString(((IMIExecutionDMContext)thread).getThreadId()));
                        if (thread instanceof IMIExecutionDMContext) {
                        	IMIExecutionDMContext dmc = (IMIExecutionDMContext) thread;
                            results.add(((Integer) dmc.getThreadId()).toString());
                        }
                    }
                } else {
                	// If any of the threads is not an IMIExecutionDMContext,
                	// we don't support thread filters at all.
                	results.clear();
                    results.add("0"); //$NON-NLS-1$    
                    break;
                }




/*******************************************************************************
 * Copyright (c) 2007, 2011 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

 * 
 * Contributors:
 *     Wind River Systems - initial API and implementation
 *     Marc Khouzam (Ericsson) - Adding javadoc (Bug 355833)
 *******************************************************************************/
package org.eclipse.cdt.dsf.debug.service;


 */
public interface IDsfBreakpointExtension extends ICBreakpointExtension {
   
    /**
     * Add the given target to the list of this breakpoint's targets.    
     * Target filters are not persisted across workbench invocations.
     * 
     * @param target the container to add to the list of this breakpoint's targets.
     * @throws CoreException if unable to set the target filter
     */
	public void setTargetFilter(IContainerDMContext target) throws CoreException;
	
    /**
     * Removes the given target from the breakpoint's target list.
     * The breakpoint has no effect in the given target. 
     * 
     * @param target the container filter to be removed
     * @exception CoreException if unable to remove the target filter
     */
    public void removeTargetFilter(IContainerDMContext target) throws CoreException;
    
    /**
     * Returns all target filters set on this breakpoint.
     * 
     * @return the targets that this breakpoint is restricted to
     * @exception CoreException if unable to determine this breakpoint's target filters
     */
    public IContainerDMContext[] getTargetFilters() throws CoreException;

    /**
     * Restricts this breakpoint to suspend only in the given threads 
     * when encountered in the given threads' target. 
     * All threads must be from the same target.
     * Thread filters are not persisted across workbench invocations.
     * 
     * @param threads the thread filters to be set
     * @exception CoreException if unable to set the thread filters
     */
    public void setThreadFilters(IExecutionDMContext[] threads) throws CoreException;

    /**
     * Removes this breakpoint's thread filters in the given target, if any. 
     * Has no effect if this breakpoint does not have filters in the given target.
     * All threads must be from the same target.
     * 
     * @param threads the thread filters to be removed
     * @exception CoreException if unable to remove the thread filter
     */
    public void removeThreadFilters(IExecutionDMContext[] threads) throws CoreException;
    
    /**
     * Returns the threads in the given target in which this breakpoint
     * is enabled or <code>null</code> if this breakpoint is enabled in
     * all threads in the given target.
     * 
     * @return the threads in the given target that this breakpoint is enabled for
     * @exception CoreException if unable to determine this breakpoint's thread filters
     */
    public IExecutionDMContext[] getThreadFilters(IContainerDMContext target) throws CoreException;
}

Return to bug 355833

Lines 302-328 Link Here

(-)a/dsf-gdb/org.eclipse.cdt.dsf.gdb.ui/src/org/eclipse/cdt/dsf/gdb/internal/ui/breakpoints/GdbThreadFilterEditor.java (-14 / +6 lines)
302	* a thread filter in a given thread, that thread should be checked.	302	* a thread filter in a given thread, that thread should be checked.
303	*/	303	*/
304	protected void setInitialCheckedState() {	304	protected void setInitialCheckedState() {
305	CBreakpointGdbThreadsFilterExtension filterExtension = fPage.getFilterExtension();	305	CBreakpointGdbThreadsFilterExtension filterExtension = fPage.getFilterExtension();
306	try {	306	try {
307	IContainerDMContext[] targets = filterExtension.getTargetFilters();	307	IContainerDMContext[] targets = filterExtension.getTargetFilters();
308
309	// TODO: Hack to properly initialize the target/thread list
310	// Should be done in filterExtension.initialize() but we don't know
311	// how to get the target list from an ICBreakpoint...
312	if (targets.length == 0) {
313	targets = getDebugTargets();
314	for (IContainerDMContext target : targets) {
315	filterExtension.setTargetFilter(target);
316	}
317	}
318	// TODO: End of hack
319		308
320	for (int i = 0; i < targets.length; i++) {	309	for (int i = 0; i < targets.length; i++) {
321	IExecutionDMContext[] filteredThreads = filterExtension.getThreadFilters(targets[i]);	310	IExecutionDMContext[] filteredThreads = filterExtension.getThreadFilters(targets[i]);
322	if (filteredThreads != null) {	311	if (filteredThreads != null) {
323	for (int j = 0; j < filteredThreads.length; ++j)	312	for (int j = 0; j < filteredThreads.length; ++j) {
		313	// Mark this thread as selected
324	fCheckHandler.checkThread(filteredThreads[j], true);	314	fCheckHandler.checkThread(filteredThreads[j], true);
		315	}
325	} else {	316	} else {
		317	// Mark the entire process as selected
326	fCheckHandler.checkTarget(targets[i], true);	318	fCheckHandler.checkTarget(targets[i], true);
327	}	319	}
328	}	320	}
Lines 332-338 Link Here
332	}	324	}
333		325
334	protected void doStore() {	326	protected void doStore() {
335	CBreakpointGdbThreadsFilterExtension filterExtension = fPage.getFilterExtension();	327	CBreakpointGdbThreadsFilterExtension filterExtension = fPage.getFilterExtension();
336	IContainerDMContext[] targets = getDebugTargets();	328	IContainerDMContext[] targets = getDebugTargets();
337	for (int i = 0; i < targets.length; ++i) {	329	for (int i = 0; i < targets.length; ++i) {
338	try {	330	try {

Lines 1-5 Link Here

(-)a/dsf-gdb/org.eclipse.cdt.dsf.gdb/src/org/eclipse/cdt/dsf/mi/service/MIBreakpointsManager.java (-36 / +74 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2010 Wind River and others.	2	* Copyright (c) 2007, 2011 Wind River and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-16 Link Here
11	* Ericsson - Added breakpoint filter support	11	* Ericsson - Added breakpoint filter support
12	* Ericsson - Re-factored the service and put a few comments	12	* Ericsson - Re-factored the service and put a few comments
13	* Ericsson - Added Action support	13	* Ericsson - Added Action support
		14	* Marc Khouzam (Ericsson) - Fix support for thread filter (Bug 355833)
14	*******************************************************************************/	15	*******************************************************************************/
15		16
16	package org.eclipse.cdt.dsf.mi.service;	17	package org.eclipse.cdt.dsf.mi.service;
Lines 422-428 Link Here
422	// Upon determining the debuggerPath, the breakpoint is installed	423	// Upon determining the debuggerPath, the breakpoint is installed
423	determineDebuggerPath(dmc, attributes, new RequestMonitor(getExecutor(), countingRm) {	424	determineDebuggerPath(dmc, attributes, new RequestMonitor(getExecutor(), countingRm) {
424	@Override	425	@Override
425	protected void handleSuccess() {	426	protected void handleSuccess() {
		427	// Before installing a breakpoint, set the target filter for that target.
		428	// Even if the breakpoint is disabled when we start, the target filter
		429	// can be accessed by the user through the breakpoint properties UI, so
		430	// we must set it right now.
		431	// This is the reason we don't do this in 'installBreakpoint', which is not
		432	// called right away if the breakpoint is disabled.
		433	try {
		434	IContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IContainerDMContext.class);
		435	IDsfBreakpointExtension filterExt = getFilterExtension(breakpoint);
		436	if (filterExt.getThreadFilters(containerDmc) == null) {
		437	// Do this only if there wasn't already an entry, or else we would
		438	// erase the content of that previous entry.
		439	filterExt.setTargetFilter(containerDmc);
		440	}
		441	} catch (CoreException e) {
		442	}
		443
426	// Install only if the breakpoint is enabled at startup (Bug261082)	444	// Install only if the breakpoint is enabled at startup (Bug261082)
427	// Note that Tracepoints are not affected by "skip-all"	445	// Note that Tracepoints are not affected by "skip-all"
428	boolean bpEnabled = attributes.get(ICBreakpoint.ENABLED).equals(true) &&	446	boolean bpEnabled = attributes.get(ICBreakpoint.ENABLED).equals(true) &&
Lines 718-723 Link Here
718	final Map<ICBreakpoint, Set<String>> threadsIDs = fBreakpointThreads.get(dmc);	736	final Map<ICBreakpoint, Set<String>> threadsIDs = fBreakpointThreads.get(dmc);
719	assert threadsIDs != null;	737	assert threadsIDs != null;
720		738
		739	// Remove any target filter (if any)
		740	try {
		741	IContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IContainerDMContext.class);
		742	getFilterExtension(breakpoint).removeTargetFilter(containerDmc);
		743	}
		744	catch( CoreException e ) {
		745	}
		746
721	// Remove breakpoint problem marker (if any)	747	// Remove breakpoint problem marker (if any)
722	removeBreakpointProblemMarker(breakpoint);	748	removeBreakpointProblemMarker(breakpoint);
723		749
Lines 1127-1132 Link Here
1127	new RequestMonitor(getExecutor(), countingRm) {	1153	new RequestMonitor(getExecutor(), countingRm) {
1128	@Override	1154	@Override
1129	protected void handleSuccess() {	1155	protected void handleSuccess() {
		1156	// For a new breakpoint, set the target filter.
		1157	try {
		1158	IContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IContainerDMContext.class);
		1159	IDsfBreakpointExtension filterExt = getFilterExtension((ICBreakpoint)breakpoint);
		1160	if (filterExt.getThreadFilters(containerDmc) == null) {
		1161	// Do this only if there wasn't already an entry, or else we would
		1162	// erase the content of that previous entry.
		1163	filterExt.setTargetFilter(containerDmc);
		1164	}
		1165	} catch (CoreException e) {
		1166	}
		1167
1130	installBreakpoint(dmc, (ICBreakpoint) breakpoint,	1168	installBreakpoint(dmc, (ICBreakpoint) breakpoint,
1131	attrs, countingRm);	1169	attrs, countingRm);
1132	}	1170	}
Lines 1372-1386 Link Here
1372	for (IBreakpointsTargetDMContext ctx : fPlatformBPs.keySet()) {	1410	for (IBreakpointsTargetDMContext ctx : fPlatformBPs.keySet()) {
1373	Map<ICBreakpoint, Map<String, Object>> breakpoints = fPlatformBPs.get(ctx);	1411	Map<ICBreakpoint, Map<String, Object>> breakpoints = fPlatformBPs.get(ctx);
1374	clearBreakpointStatus(breakpoints.keySet().toArray(new ICBreakpoint[breakpoints.size()]), ctx);	1412	clearBreakpointStatus(breakpoints.keySet().toArray(new ICBreakpoint[breakpoints.size()]), ctx);
		1413
		1414	// Also clear any target filter since we will not be calling uninstallBreakpoint() which
		1415	// usually does that work.
		1416	IContainerDMContext dmc = DMContexts.getAncestorOfType(ctx, IContainerDMContext.class);
		1417	clearTargetFilter(dmc, breakpoints.keySet());
1375	}	1418	}
1376	// This will prevent Shutdown() from trying to remove bps from a	1419	// This will prevent Shutdown() from trying to remove bps from a
1377	// backend that has already shutdown	1420	// backend that has already shutdown
1378	fPlatformBPs.clear();	1421	fPlatformBPs.clear();
1379	}	1422	}
1380		1423
1381	///////////////////////////////////////////////////////////////////////////	1424	private void clearTargetFilter(IContainerDMContext containerDmc, Set<ICBreakpoint> breakpoints) {
1382	// Breakpoint status handling functions	1425	// Remove any target filter (if any)
1383	///////////////////////////////////////////////////////////////////////////	1426	try {
		1427	for (ICBreakpoint bp : breakpoints) {
		1428	getFilterExtension(bp).removeTargetFilter(containerDmc);
		1429	}
		1430	}
		1431	catch( CoreException e ) {
		1432	}
		1433	}
		1434
1384		1435
1385	/**	1436	/**
1386	* @param bps	1437	* @param bps
Lines 1651-1691 Link Here
1651	* @return	1702	* @return
1652	*/	1703	*/
1653	private Set<String> extractThreads(IBreakpointsTargetDMContext context, ICBreakpoint breakpoint) {	1704	private Set<String> extractThreads(IBreakpointsTargetDMContext context, ICBreakpoint breakpoint) {
1654	Set<String> results = new HashSet<String>();	1705	Set<String> results = new HashSet<String>();
		1706
		1707	IExecutionDMContext[] threads = null;
		1708	try {
		1709	IContainerDMContext containerDmc = DMContexts.getAncestorOfType(context, IContainerDMContext.class);
		1710	threads = getFilterExtension(breakpoint).getThreadFilters(containerDmc);
		1711	} catch (CoreException e) {
		1712	}
1655		1713
1656	// Find the ancestor	1714	if (threads == null \|\| threads.length == 0) {
1657	List<IExecutionDMContext[]> threads = new ArrayList<IExecutionDMContext[]>(1);	1715	results.add("0"); //$NON-NLS-1$
1658		1716	return results;
1659	try {
1660	// Retrieve the targets
1661	IDsfBreakpointExtension filterExtension = getFilterExtension(breakpoint);
1662	IContainerDMContext[] targets = filterExtension.getTargetFilters();
1663
1664	// If no target is present, breakpoint applies to all.
1665	if (targets.length == 0) {
1666	results.add("0"); //$NON-NLS-1$
1667	return results;
1668	}
1669
1670	// Extract the thread IDs (if there is none, we are covered)
1671	for (IContainerDMContext ctxt : targets) {
1672	if (ctxt.equals(context) \|\| DMContexts.isAncestorOf(ctxt, context)) {
1673	threads.add(filterExtension.getThreadFilters(ctxt));
1674	}
1675	}
1676	} catch (CoreException e1) {
1677	}	1717	}
1678		1718
1679	if (supportsThreads(breakpoint)) {	1719	if (supportsThreads(breakpoint)) {
1680	for (IExecutionDMContext[] targetThreads : threads) {	1720	for (IExecutionDMContext thread : threads) {
1681	if (targetThreads != null) {	1721	if (thread instanceof IMIExecutionDMContext) {
1682	for (IExecutionDMContext thread : targetThreads) {	1722	results.add(Integer.toString(((IMIExecutionDMContext)thread).getThreadId()));
1683	if (thread instanceof IMIExecutionDMContext) {
1684	IMIExecutionDMContext dmc = (IMIExecutionDMContext) thread;
1685	results.add(((Integer) dmc.getThreadId()).toString());
1686	}
1687	}
1688	} else {	1723	} else {
		1724	// If any of the threads is not an IMIExecutionDMContext,
		1725	// we don't support thread filters at all.
		1726	results.clear();
1689	results.add("0"); //$NON-NLS-1$	1727	results.add("0"); //$NON-NLS-1$
1690	break;	1728	break;
1691	}	1729	}

Lines 1-5 Link Here

(-)a/dsf/org.eclipse.cdt.dsf/src/org/eclipse/cdt/dsf/debug/service/IDsfBreakpointExtension.java (-6 / +55 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 Wind River Systems and others.	2	* Copyright (c) 2007, 2011 Wind River Systems and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Wind River Systems - initial API and implementation	9	* Wind River Systems - initial API and implementation
		10	* Marc Khouzam (Ericsson) - Adding javadoc (Bug 355833)
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.cdt.dsf.debug.service;	12	package org.eclipse.cdt.dsf.debug.service;
12		13
Lines 35-46 Link Here
35	*/	36	*/
36	public interface IDsfBreakpointExtension extends ICBreakpointExtension {	37	public interface IDsfBreakpointExtension extends ICBreakpointExtension {
37		38
38	public void setTargetFilter( IContainerDMContext target ) throws CoreException;	39	/**
39	public void removeTargetFilter( IContainerDMContext target ) throws CoreException;	40	* Add the given target to the list of this breakpoint's targets.
		41	* Target filters are not persisted across workbench invocations.
		42	*
		43	* @param target the container to add to the list of this breakpoint's targets.
		44	* @throws CoreException if unable to set the target filter
		45	*/
		46	public void setTargetFilter(IContainerDMContext target) throws CoreException;
		47
		48	/**
		49	* Removes the given target from the breakpoint's target list.
		50	* The breakpoint has no effect in the given target.
		51	*
		52	* @param target the container filter to be removed
		53	* @exception CoreException if unable to remove the target filter
		54	*/
		55	public void removeTargetFilter(IContainerDMContext target) throws CoreException;
		56
		57	/**
		58	* Returns all target filters set on this breakpoint.
		59	*
		60	* @return the targets that this breakpoint is restricted to
		61	* @exception CoreException if unable to determine this breakpoint's target filters
		62	*/
40	public IContainerDMContext[] getTargetFilters() throws CoreException;	63	public IContainerDMContext[] getTargetFilters() throws CoreException;
41		64
42	public void setThreadFilters( IExecutionDMContext[] threads ) throws CoreException;	65	/**
43	public void removeThreadFilters( IExecutionDMContext[] threads ) throws CoreException;	66	* Restricts this breakpoint to suspend only in the given threads
44	public IExecutionDMContext[] getThreadFilters( IContainerDMContext target ) throws CoreException;	67	* when encountered in the given threads' target.
		68	* All threads must be from the same target.
		69	* Thread filters are not persisted across workbench invocations.
		70	*
		71	* @param threads the thread filters to be set
		72	* @exception CoreException if unable to set the thread filters
		73	*/
		74	public void setThreadFilters(IExecutionDMContext[] threads) throws CoreException;
45		75
		76	/**
		77	* Removes this breakpoint's thread filters in the given target, if any.
		78	* Has no effect if this breakpoint does not have filters in the given target.
		79	* All threads must be from the same target.
		80	*
		81	* @param threads the thread filters to be removed
		82	* @exception CoreException if unable to remove the thread filter
		83	*/
		84	public void removeThreadFilters(IExecutionDMContext[] threads) throws CoreException;
		85
		86	/**
		87	* Returns the threads in the given target in which this breakpoint
		88	* is enabled or <code>null</code> if this breakpoint is enabled in
		89	* all threads in the given target.
		90	*
		91	* @return the threads in the given target that this breakpoint is enabled for
		92	* @exception CoreException if unable to determine this breakpoint's thread filters
		93	*/
		94	public IExecutionDMContext[] getThreadFilters(IContainerDMContext target) throws CoreException;
46	}	95	}