Attachment #151945 for bug #294874

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

View | Details | Raw Unified | Return to bug 294874
Collapse All | Expand All




import org.eclipse.cdt.debug.mi.core.output.MIShared;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.cdt.debug.mi.core.event.MIBreakpointChangedEvent;

/**
 * Manager of the CDI shared libraries.

		MISession miSession = target.getMISession();
		Session session = (Session)target.getSession();
		List eventList = updateState(target);
		// A new Libraries loaded or something change, try to update the breakpoints.
		BreakpointManager bpMgr = session.getBreakpointManager();
		MIBreakpoint[] miBPoints = bpMgr.getAllMIBreakpoints(miSession);                
		if(miBPoints != null){
			for(int p=0;p<miBPoints.length;++p){
				int no = miBPoints[p].getNumber(); 
				Breakpoint bp = bpMgr.getBreakpoint(target, no);
				if(bp != null) {
					MIBreakpoint[] miBreakpoints = bp.getMIBreakpoints();
					for(int q=0;q<miBreakpoints.length;++q){
						if(miBreakpoints[q].getNumber() == no){							
							if(!miBreakpoints[q].miFieldsEquals(miBPoints[p])){
								//update internal information on MI breakpoints and send event
								miBreakpoints[q] = miBPoints[p];		                                
								eventList.add(new MIBreakpointChangedEvent(miSession, no));
							}
		        		}
		        	}
		    	}
			}
		}

		if (eventList.size() > 0 && !miSession.getCommandFactory().pendingBreakEnabled()) {
			ICDIBreakpoint bpoints[] = null;
			try {
				bpoints = bpMgr.getDeferredBreakpoints(target);

Lines 1-4 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-2 / +2 lines)
1	#Wed Apr 08 15:56:28 BST 2009	1	#Thu Oct 29 14:12:08 MSK 2009
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
Lines 61-67 Link Here
61	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled	61	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
62	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled	62	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
63	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled	63	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
64	org.eclipse.jdt.core.compiler.problem.unusedImport=error	64	org.eclipse.jdt.core.compiler.problem.unusedImport=warning
65	org.eclipse.jdt.core.compiler.problem.unusedLabel=warning	65	org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
66	org.eclipse.jdt.core.compiler.problem.unusedLocal=warning	66	org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
67	org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore	67	org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore




public class CommandFactory {

	String fMIVersion;
	private boolean pendingBreakEnabled;

	protected CommandFactory() {
	}

	/**
	 * @param b enable/disable usage of pending breakpoints
	 */
	public void setMIPendingBreakpointEnabled(boolean b) {
		pendingBreakEnabled = b;
	}
	
	public boolean pendingBreakEnabled() {
		return pendingBreakEnabled;
	}
	
	public CommandFactory(String miVersion) {
		fMIVersion = miVersion;
	}


	public MIBreakInsert createMIBreakInsert(boolean isTemporary, boolean isHardware,
			 String condition, int ignoreCount, String line, int tid) {
		return new MIBreakInsert(getMIVersion(), isTemporary, isHardware, true, condition, ignoreCount, line, tid,pendingBreakEnabled);
	}

	public MIBreakInsert createMIBreakInsert(String func) {
		return new MIBreakInsert(getMIVersion(), func, pendingBreakEnabled);
	}

	public MIBreakList createMIBreakList() {

Lines 60-74 Link Here

(-)mi/org/eclipse/cdt/debug/mi/core/command/MIBreakInsert.java (+31 lines)
60	*/	60	*/
61	public class MIBreakInsert extends MICommand	61	public class MIBreakInsert extends MICommand
62	{	62	{
		63
		64	/**
		65	*
		66	* @deprecated
		67	*/
63	public MIBreakInsert(String miVersion, String func) {	68	public MIBreakInsert(String miVersion, String func) {
64	this(miVersion, false, false, null, 0, func, 0);	69	this(miVersion, false, false, null, 0, func, 0);
65	}	70	}
66		71
		72	public MIBreakInsert(String miVersion, String func, boolean pendingSupported) {
		73	this(miVersion, false, false, true,
		74	null, 0, func, 0, pendingSupported);
		75	}
		76
		77	/**
		78	*
		79	* @deprecated
		80	*/
67	public MIBreakInsert(String miVersion, boolean isTemporary, boolean isHardware,	81	public MIBreakInsert(String miVersion, boolean isTemporary, boolean isHardware,
68	String condition, int ignoreCount, String line, int tid) {	82	String condition, int ignoreCount, String line, int tid) {
		83	this(miVersion, isTemporary, isHardware, true,
		84	condition, ignoreCount, line, tid, false);
		85	}
		86
		87	public MIBreakInsert(String miVersion, boolean isTemporary, boolean isHardware, boolean isPending,
		88	String condition, int ignoreCount, String line, int tid, boolean pendingSupported) {
69	super(miVersion, "-break-insert"); //$NON-NLS-1$	89	super(miVersion, "-break-insert"); //$NON-NLS-1$
70		90
		91
		92	if(!pendingSupported)
		93	isPending = false;
		94
71	int i = 0;	95	int i = 0;
		96	if (isPending) {
		97	i++;
		98	}
72	if (isTemporary) {	99	if (isTemporary) {
73	i++;	100	i++;
74	}	101	}
Lines 87-92 Link Here
87	String[] opts = new String[i];	114	String[] opts = new String[i];
88		115
89	i = 0;	116	i = 0;
		117	if (isPending) {
		118	opts[i] = "-f"; //$NON-NLS-1$
		119	i++;
		120	}
90	if (isTemporary) {	121	if (isTemporary) {
91	opts[i] = "-t"; //$NON-NLS-1$	122	opts[i] = "-t"; //$NON-NLS-1$
92	i++;	123	i++;

Lines 56-61 Link Here

(-)mi/org/eclipse/cdt/debug/mi/core/output/MIBreakpoint.java (+45 lines)
56	boolean enabled;	56	boolean enabled;
57	String address;	57	String address;
58	String func = ""; //$NON-NLS-1$	58	String func = ""; //$NON-NLS-1$
		59	String pending = ""; //$NON-NLS-1$
59	String file = ""; //$NON-NLS-1$	60	String file = ""; //$NON-NLS-1$
60	int line;	61	int line;
61	String cond = ""; //$NON-NLS-1$	62	String cond = ""; //$NON-NLS-1$
Lines 69-74 Link Here
69	boolean isRWpt;	70	boolean isRWpt;
70	boolean isWWpt;	71	boolean isWWpt;
71	boolean isHdw;	72	boolean isHdw;
		73	boolean isPending;
72		74
73	public MIBreakpoint(MITuple tuple) {	75	public MIBreakpoint(MITuple tuple) {
74	parse(tuple);	76	parse(tuple);
Lines 229-238 Link Here
229	} else if (var.equals("addr")) { //$NON-NLS-1$	231	} else if (var.equals("addr")) { //$NON-NLS-1$
230	try {	232	try {
231	address = str.trim();	233	address = str.trim();
		234	//TODO: parse HEX integer up to 64 bits long and throw NumberFormatException if needed
		235	if(address.toUpperCase().equals("<PENDING>")){
		236	address = null;
		237	isPending = true;
		238	}
232	} catch (NumberFormatException e) {	239	} catch (NumberFormatException e) {
		240	isPending = true;
233	}	241	}
234	} else if (var.equals("func")) { //$NON-NLS-1$	242	} else if (var.equals("func")) { //$NON-NLS-1$
235	func = str;	243	func = str;
		244	} else if (var.equals("pending")) { //$NON-NLS-1$
		245	pending = str;
		246	isPending = true;
236	} else if (var.equals("file")) { //$NON-NLS-1$	247	} else if (var.equals("file")) { //$NON-NLS-1$
237	file = str;	248	file = str;
238	} else if (var.equals("thread")) { //$NON-NLS-1$	249	} else if (var.equals("thread")) { //$NON-NLS-1$
Lines 258-266 Link Here
258	cond = str;	269	cond = str;
259	}	270	}
260	}	271	}
		272
		273	if(isPending){
		274	if(func.trim().equals("")){
		275	func = pending;
		276	}
		277	}
261	}	278	}
262		279
263	public void setFile(String file) {	280	public void setFile(String file) {
264	this.file = file;	281	this.file = file;
265	}	282	}
		283
		284
		285	public boolean miFieldsEquals(MIBreakpoint other){
		286	boolean ret = true;
		287
		288	ret = ret & (number == other.number);
		289	ret = ret & (type.equals(other.type));
		290	ret = ret & (disp.equals(other.disp));
		291	ret = ret & (enabled == other.enabled);
		292	if(address != null){
		293	ret = ret & (address.equals(other.address));
		294	}else{
		295	ret = ret & (other.address == null);
		296	}
		297	ret = ret & (func.equals(other.func));
		298	ret = ret & (pending.equals(other.pending));
		299	ret = ret & (file.equals(other.file));
		300	ret = ret & (line == other.line);
		301	ret = ret & (cond.equals(other.cond));
		302	ret = ret & (times == other.times);
		303	ret = ret & (what.equals(other.what));
		304	ret = ret & (threadId.equals(other.threadId));
		305	ret = ret & (ignore == other.ignore);
		306
		307	return ret;
		308	}
		309
		310
266	}	311	}

Lines 18-27 Link Here

(-)mi/org/eclipse/cdt/debug/mi/core/MISession.java (-2 / +100 lines)
18	import java.io.OutputStream;	18	import java.io.OutputStream;
19	import java.io.PipedInputStream;	19	import java.io.PipedInputStream;
20	import java.io.PipedOutputStream;	20	import java.io.PipedOutputStream;
		21	import java.util.ArrayList;
		22	import java.util.List;
21	import java.util.Observable;	23	import java.util.Observable;
22		24
23	import org.eclipse.cdt.debug.mi.core.command.Command;	25	import org.eclipse.cdt.debug.mi.core.command.Command;
24	import org.eclipse.cdt.debug.mi.core.command.CommandFactory;	26	import org.eclipse.cdt.debug.mi.core.command.CommandFactory;
		27	import org.eclipse.cdt.debug.mi.core.command.MICommand;
25	import org.eclipse.cdt.debug.mi.core.command.MIExecInterrupt;	28	import org.eclipse.cdt.debug.mi.core.command.MIExecInterrupt;
26	import org.eclipse.cdt.debug.mi.core.command.MIGDBExit;	29	import org.eclipse.cdt.debug.mi.core.command.MIGDBExit;
27	import org.eclipse.cdt.debug.mi.core.command.MIGDBSet;	30	import org.eclipse.cdt.debug.mi.core.command.MIGDBSet;
Lines 31-39 Link Here
31	import org.eclipse.cdt.debug.mi.core.command.MIVersion;	34	import org.eclipse.cdt.debug.mi.core.command.MIVersion;
32	import org.eclipse.cdt.debug.mi.core.event.MIEvent;	35	import org.eclipse.cdt.debug.mi.core.event.MIEvent;
33	import org.eclipse.cdt.debug.mi.core.event.MIGDBExitEvent;	36	import org.eclipse.cdt.debug.mi.core.event.MIGDBExitEvent;
		37	import org.eclipse.cdt.debug.mi.core.output.MIBreakInsertInfo;
		38	import org.eclipse.cdt.debug.mi.core.output.MIBreakpoint;
		39	import org.eclipse.cdt.debug.mi.core.output.MIConst;
34	import org.eclipse.cdt.debug.mi.core.output.MIGDBShowInfo;	40	import org.eclipse.cdt.debug.mi.core.output.MIGDBShowInfo;
		41	import org.eclipse.cdt.debug.mi.core.output.MIInfo;
		42	import org.eclipse.cdt.debug.mi.core.output.MIList;
35	import org.eclipse.cdt.debug.mi.core.output.MIOutput;	43	import org.eclipse.cdt.debug.mi.core.output.MIOutput;
36	import org.eclipse.cdt.debug.mi.core.output.MIParser;	44	import org.eclipse.cdt.debug.mi.core.output.MIParser;
		45	import org.eclipse.cdt.debug.mi.core.output.MIResult;
		46	import org.eclipse.cdt.debug.mi.core.output.MIResultRecord;
		47	import org.eclipse.cdt.debug.mi.core.output.MITuple;
		48	import org.eclipse.cdt.debug.mi.core.output.MIValue;
37	import org.eclipse.core.runtime.IProgressMonitor;	49	import org.eclipse.core.runtime.IProgressMonitor;
38	import org.eclipse.core.runtime.NullProgressMonitor;	50	import org.eclipse.core.runtime.NullProgressMonitor;
39		51
Lines 111-116 Link Here
111	*/	123	*/
112	public MISession(MIProcess process, IMITTY tty, int type, int commandTimeout, int launchTimeout, String miVersion, IProgressMonitor monitor) throws MIException {	124	public MISession(MIProcess process, IMITTY tty, int type, int commandTimeout, int launchTimeout, String miVersion, IProgressMonitor monitor) throws MIException {
113	this(process, tty, type, new CommandFactory(miVersion), commandTimeout, launchTimeout, monitor);	125	this(process, tty, type, new CommandFactory(miVersion), commandTimeout, launchTimeout, monitor);
		126	inqureGDBFeatures();
114	}	127	}
115		128
116		129
Lines 130-135 Link Here
130	// if exec console is present, assume MI2 supported	143	// if exec console is present, assume MI2 supported
131	setCommandFactory(new CommandFactory(MIVersion.MI2));	144	setCommandFactory(new CommandFactory(MIVersion.MI2));
132	}	145	}
		146	inqureGDBFeatures();
133	}	147	}
134		148
135	/**	149	/**
Lines 166-171 Link Here
166		180
167	// initialize/setup	181	// initialize/setup
168	setup(launchTimeout, new NullProgressMonitor());	182	setup(launchTimeout, new NullProgressMonitor());
		183	inqureGDBFeatures();
169	}	184	}
170		185
171	/**	186	/**
Lines 179-185 Link Here
179	*	194	*
180	* @since 3.1	195	* @since 3.1
181	*/	196	*/
182	public MISession(MIProcess process, IMITTY tty, int type, CommandFactory commandFactory, int commandTimeout) throws MIException {	197	public MISession(MIProcess process, IMITTY tty, int type, CommandFactory commandFactory, int commandTimeout) throws MIException {
183	gdbProcess = process;	198	gdbProcess = process;
184	inChannel = process.getInputStream();	199	inChannel = process.getInputStream();
185	outChannel = process.getOutputStream();	200	outChannel = process.getOutputStream();
Lines 205-211 Link Here
205		220
206	txThread.start();	221	txThread.start();
207	rxThread.start();	222	rxThread.start();
208	eventThread.start();	223	eventThread.start();
		224
		225	inqureGDBFeatures();
209	}	226	}
210		227
211	/**	228	/**
Lines 860-863 Link Here
860	public final void setBreakpointsWithFullName(boolean breakpointsWithFullName) {	877	public final void setBreakpointsWithFullName(boolean breakpointsWithFullName) {
861	this.breakpointsWithFullName = breakpointsWithFullName;	878	this.breakpointsWithFullName = breakpointsWithFullName;
862	}	879	}
		880
		881
		882	private final void inqureGDBFeatures() {
		883	try{
		884	MIGdbListFearutes features = new MIGdbListFearutes(null);
		885	postCommand(features);
		886	factory.setMIPendingBreakpointEnabled(features.getMIInfo().pendingBrekpoints);
		887	}catch(MIException e){
		888	e.printStackTrace();
		889	}
		890	}
		891	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		892	static class MIGdbListFearutes extends MICommand{
		893	boolean pendingBrekpoints;
		894	boolean threadInfo;
		895	boolean frozenVarobjs;
		896
		897	public MIGdbListFearutes(String miVersion) {
		898	super(miVersion, "-list-features"); //$NON-NLS-1$
		899	setParameters(new String[]{""});
		900	}
		901
		902
		903	public MIGdbFeaturesInfo getMIInfo() throws MIException {
		904	MIGdbFeaturesInfo info = null;
		905	MIOutput out = getMIOutput();
		906	if (out != null) {
		907	info = new MIGdbFeaturesInfo(out);
		908	if (info.isError()) {
		909	throwMIException(info, out);
		910	}
		911	}
		912	return info;
		913	}
		914
		915	}
		916	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		917	public static class MIGdbFeaturesInfo extends MIInfo{
		918	boolean pendingBrekpoints;
		919	boolean threadInfo;
		920	boolean frozenVarobjs;
		921
		922	public MIGdbFeaturesInfo(MIOutput record) {
		923	super(record);
		924	parse();
		925	}
		926
		927
		928
		929	void parse() {
		930	//List aList = new ArrayList(1);
		931	if (isDone()) {
		932	MIOutput out = getMIOutput();
		933	MIResultRecord rr = out.getMIResultRecord();
		934	if (rr != null) {
		935	MIResult[] results = rr.getMIResults();
		936	for (int i = 0; i < results.length; i++) {
		937	String var = results[i].getVariable();
		938	MIList valList = (MIList)(results[i].getMIValue());
		939	MIValue[] values = valList.getMIValues();
		940	for(int j=0;j<values.length;++j){
		941	String val=((MIConst)values[j]).getString();
		942	if("pending-breakpoints".equals(val)){
		943	pendingBrekpoints = true;
944	} else if("thread-info".equals(val)){
945	threadInfo = true;
946	} else if("frozen-varobjs".equals(val)){
947	frozenVarobjs = true;
948	}
949	}
950	}
951
952	}
953	}
954
955	}
956
957
958
959	}
960	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
863	}	961	}





import org.eclipse.cdt.debug.mi.core.GDBProcess;
import org.eclipse.cdt.debug.mi.core.cdi.model.Target;
import org.eclipse.cdt.debug.mi.core.event.MIBreakpointChangedEvent;
import org.eclipse.cdt.debug.mi.ui.console.actions.MiConsoleSaveAction;
import org.eclipse.cdt.debug.mi.ui.console.actions.MiConsoleVerboseModeAction;
import org.eclipse.debug.core.DebugEvent;

			}
		}
	}

	/** 
	 * Handle MISession notification
	 */
	 public void update(Observable arg0, Object arg1) {
		 if((arg1!=null) && 
				 ((arg1 instanceof VerboseModeChangedEvent) || (arg1 instanceof MIBreakpointChangedEvent)) 
				 && (fVerboseMode != null)) {			 
			try {

				fVerboseMode.updateStateAndEnablement();
			} catch (Exception e) {
			}          

Return to bug 294874

Lines 59-64 Link Here

(-)cdi/org/eclipse/cdt/debug/mi/core/cdi/SharedLibraryManager.java (-3 / +24 lines)
59	import org.eclipse.cdt.debug.mi.core.output.MIShared;	59	import org.eclipse.cdt.debug.mi.core.output.MIShared;
60	import org.eclipse.core.runtime.IPath;	60	import org.eclipse.core.runtime.IPath;
61	import org.eclipse.core.runtime.Path;	61	import org.eclipse.core.runtime.Path;
		62	import org.eclipse.cdt.debug.mi.core.event.MIBreakpointChangedEvent;
62		63
63	/**	64	/**
64	* Manager of the CDI shared libraries.	65	* Manager of the CDI shared libraries.
Lines 134-142 Link Here
134	MISession miSession = target.getMISession();	135	MISession miSession = target.getMISession();
135	Session session = (Session)target.getSession();	136	Session session = (Session)target.getSession();
136	List eventList = updateState(target);	137	List eventList = updateState(target);
137	// A new Libraries loaded or something change, try to set the breakpoints.	138	// A new Libraries loaded or something change, try to update the breakpoints.
138	if (eventList.size() > 0) {	139	BreakpointManager bpMgr = session.getBreakpointManager();
139	BreakpointManager bpMgr = session.getBreakpointManager();	140	MIBreakpoint[] miBPoints = bpMgr.getAllMIBreakpoints(miSession);
		141	if(miBPoints != null){
		142	for(int p=0;p<miBPoints.length;++p){
		143	int no = miBPoints[p].getNumber();
		144	Breakpoint bp = bpMgr.getBreakpoint(target, no);
		145	if(bp != null) {
		146	MIBreakpoint[] miBreakpoints = bp.getMIBreakpoints();
		147	for(int q=0;q<miBreakpoints.length;++q){
		148	if(miBreakpoints[q].getNumber() == no){
		149	if(!miBreakpoints[q].miFieldsEquals(miBPoints[p])){
		150	//update internal information on MI breakpoints and send event
		151	miBreakpoints[q] = miBPoints[p];
		152	eventList.add(new MIBreakpointChangedEvent(miSession, no));
		153	}
		154	}
		155	}
		156	}
		157	}
		158	}
		159
		160	if (eventList.size() > 0 && !miSession.getCommandFactory().pendingBreakEnabled()) {
140	ICDIBreakpoint bpoints[] = null;	161	ICDIBreakpoint bpoints[] = null;
141	try {	162	try {
142	bpoints = bpMgr.getDeferredBreakpoints(target);	163	bpoints = bpMgr.getDeferredBreakpoints(target);

Lines 409-415 Link Here

(-)cdi/org/eclipse/cdt/debug/mi/core/cdi/BreakpointManager.java (-2 / +3 lines)
409	MIBreakpoint[] miBps = bp.getMIBreakpoints();	409	MIBreakpoint[] miBps = bp.getMIBreakpoints();
410	for (int j = 0; j < miBps.length; j++) {	410	for (int j = 0; j < miBps.length; j++) {
411	if (miBps[j].getNumber() == no) {	411	if (miBps[j].getNumber() == no) {
412	if (hasBreakpointChanged(miBps[j], miBreakpoint)) {	412	//if (hasBreakpointChanged(miBps[j], miBreakpoint)) {
		413	if(true){
413	miBps[j] = miBreakpoint;	414	miBps[j] = miBreakpoint;
414	bp.setEnabled0(miBreakpoint.isEnabled());	415	bp.setEnabled0(miBreakpoint.isEnabled());
415	// FIXME: We have a problem if the thread id change.	416	// FIXME: We have a problem if the thread id change.
Lines 479-485 Link Here
479	} else {	480	} else {
480	MIPlugin.log("Unsupported event breakpoint: "+miBreakpoint.getWhat()); //$NON-NLS-1$ log entry not for users	481	MIPlugin.log("Unsupported event breakpoint: "+miBreakpoint.getWhat()); //$NON-NLS-1$ log entry not for users
481	}	482	}
482	} else if (addr != null && addr.length() > 0) {	483	} else if (addr != null && addr.length() > 0) {// addr may be "<PENDING>"
483	BigInteger big = MIFormat.getBigInteger(addr);	484	BigInteger big = MIFormat.getBigInteger(addr);
484	AddressLocation location = createAddressLocation(big);	485	AddressLocation location = createAddressLocation(big);
485	newBreakpoint = new AddressBreakpoint(target, type, location, condition,	486	newBreakpoint = new AddressBreakpoint(target, type, location, condition,

Lines 27-36 Link Here

(-)mi/org/eclipse/cdt/debug/mi/core/command/CommandFactory.java (-2 / +14 lines)
27	public class CommandFactory {	27	public class CommandFactory {
28		28
29	String fMIVersion;	29	String fMIVersion;
		30	private boolean pendingBreakEnabled;
30		31
31	protected CommandFactory() {	32	protected CommandFactory() {
32	}	33	}
33		34
		35	/**
		36	* @param b enable/disable usage of pending breakpoints
		37	*/
		38	public void setMIPendingBreakpointEnabled(boolean b) {
		39	pendingBreakEnabled = b;
		40	}
		41
		42	public boolean pendingBreakEnabled() {
		43	return pendingBreakEnabled;
		44	}
		45
34	public CommandFactory(String miVersion) {	46	public CommandFactory(String miVersion) {
35	fMIVersion = miVersion;	47	fMIVersion = miVersion;
36	}	48	}
Lines 65-75 Link Here
65		77
66	public MIBreakInsert createMIBreakInsert(boolean isTemporary, boolean isHardware,	78	public MIBreakInsert createMIBreakInsert(boolean isTemporary, boolean isHardware,
67	String condition, int ignoreCount, String line, int tid) {	79	String condition, int ignoreCount, String line, int tid) {
68	return new MIBreakInsert(getMIVersion(), isTemporary, isHardware, condition, ignoreCount, line, tid);	80	return new MIBreakInsert(getMIVersion(), isTemporary, isHardware, true, condition, ignoreCount, line, tid,pendingBreakEnabled);
69	}	81	}
70		82
71	public MIBreakInsert createMIBreakInsert(String func) {	83	public MIBreakInsert createMIBreakInsert(String func) {
72	return new MIBreakInsert(getMIVersion(), func);	84	return new MIBreakInsert(getMIVersion(), func, pendingBreakEnabled);
73	}	85	}
74		86
75	public MIBreakList createMIBreakList() {	87	public MIBreakList createMIBreakList() {

Lines 16-21 Link Here

(-)src/org/eclipse/cdt/debug/mi/ui/console/MiConsolePageParticipant.java (-3 / +6 lines)
16		16
17	import org.eclipse.cdt.debug.mi.core.GDBProcess;	17	import org.eclipse.cdt.debug.mi.core.GDBProcess;
18	import org.eclipse.cdt.debug.mi.core.cdi.model.Target;	18	import org.eclipse.cdt.debug.mi.core.cdi.model.Target;
		19	import org.eclipse.cdt.debug.mi.core.event.MIBreakpointChangedEvent;
19	import org.eclipse.cdt.debug.mi.ui.console.actions.MiConsoleSaveAction;	20	import org.eclipse.cdt.debug.mi.ui.console.actions.MiConsoleSaveAction;
20	import org.eclipse.cdt.debug.mi.ui.console.actions.MiConsoleVerboseModeAction;	21	import org.eclipse.cdt.debug.mi.ui.console.actions.MiConsoleVerboseModeAction;
21	import org.eclipse.debug.core.DebugEvent;	22	import org.eclipse.debug.core.DebugEvent;
Lines 105-117 Link Here
105	}	106	}
106	}	107	}
107	}	108	}
108
109	/**	109	/**
110	* Handle MISession notification	110	* Handle MISession notification
111	*/	111	*/
112	public void update(Observable arg0, Object arg1) {	112	public void update(Observable arg0, Object arg1) {
113	if((arg1!=null) && (arg1 instanceof VerboseModeChangedEvent) && (fVerboseMode != null)) {	113	if((arg1!=null) &&
114	try {	114	((arg1 instanceof VerboseModeChangedEvent) \|\| (arg1 instanceof MIBreakpointChangedEvent))
		115	&& (fVerboseMode != null)) {
		116	try {
		117
115	fVerboseMode.updateStateAndEnablement();	118	fVerboseMode.updateStateAndEnablement();
116	} catch (Exception e) {	119	} catch (Exception e) {
117	}	120	}