<extension

         point="org.eclipse.debug.core.statusHandlers">

      <statusHandler

            class="org.eclipse.cdt.dsf.gdb.internal.ui.GdbStatusHandler"

            code="20001"

            id="org.eclipse.cdt.dsf.gdb.ui.statusHandler"

            plugin="org.eclipse.cdt.dsf.gdb">

      </statusHandler>

   </extension>

/*******************************************************************************

 * Copyright (c) 2011 Mentor Graphics 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:

 * Mentor Graphics - Initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.internal.ui;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.debug.core.IStatusHandler;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

public class GdbStatusHandler implements IStatusHandler {

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.IStatusHandler#handleStatus(org.eclipse.core.runtime.IStatus, java.lang.Object)

	 */

	@Override

	public Object handleStatus( final IStatus status, Object source ) throws CoreException {

		Runnable runnable = null;

		if ( status.getSeverity() == IStatus.ERROR ) {

			runnable = new Runnable() {

				@Override

				public void run() {

					Shell parent = GdbUIPlugin.getActiveWorkbenchShell();

					if ( parent != null )

						MessageDialog.openError( parent, Messages.GdbStatusHandler_Error, status.getMessage() );

				}

			};

		}

		else if ( status.getSeverity() == IStatus.WARNING ) {

			runnable = new Runnable() {

				@Override

				public void run() {

					Shell parent = GdbUIPlugin.getActiveWorkbenchShell();

					if ( parent != null )

						MessageDialog.openWarning( parent, Messages.GdbStatusHandler_Warning, status.getMessage() );

				}

			};

		}

		else if ( status.getSeverity() == IStatus.INFO ) {

			runnable = new Runnable() {

				@Override

				public void run() {

					Shell parent = GdbUIPlugin.getActiveWorkbenchShell();

					if ( parent != null )

						MessageDialog.openInformation( parent, Messages.GdbStatusHandler_Information, status.getMessage() );

				}

			};

		}

		if ( runnable != null )

			Display.getDefault().asyncExec( runnable );

		return null;

	}

}

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.jface.resource.ImageRegistry;

import org.eclipse.swt.graphics.Image;

    /* (non-Javadoc)

	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#initializeImageRegistry(org.eclipse.jface.resource.ImageRegistry)

	 */

	@Override

	protected void initializeImageRegistry( ImageRegistry reg ) {

		super.initializeImageRegistry( reg );

		declareImages( reg );

	}

	/**

     * Returns an image descriptor for the image file at the given

     * plug-in relative path

     *

     * @param path the path

     * @return the image descriptor

     */

    public static ImageDescriptor getImageDescriptor(String path) {

        return imageDescriptorFromPlugin(PLUGIN_ID, path);

    }

    public static Image getImage( String key ) {

    	return getDefault().getImageRegistry().get( key );

    }

    private void declareImages( ImageRegistry reg ) {

    	reg.put( IGdbUIConstants.IMG_WIZBAN_ADVANCED_TIMEOUT_SETTINGS, 

    			getImageDescriptor( "icons/full/wizban/advtosettings_wiz.png" ) ); //$NON-NLS-1$

    }

/*******************************************************************************

 * Copyright (c) 2011 Mentor Graphics 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:

 * Mentor Graphics - Initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.internal.ui;

/**

 * @noimplement This interface is not intended to be implemented by clients.

 * 

 * @since 4.1

 */

public interface IGdbUIConstants {

	/**

	 * Plug-in identifier (value <code>"org.eclipse.cdt.dsf.gdb.ui"</code>).

	 */

	public static final String PLUGIN_ID = GdbUIPlugin.PLUGIN_ID; 

	/**  image identifier. */

	public static final String IMG_WIZBAN_ADVANCED_TIMEOUT_SETTINGS = PLUGIN_ID + ".imageAdvancedTimeoutSettings"; //$NON-NLS-1$

}

/*******************************************************************************

 * Copyright (c) 2011 Mentor Graphics 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:

 * Mentor Graphics - Initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.internal.ui;

import org.eclipse.osgi.util.NLS;

public class Messages extends NLS {

	private static final String BUNDLE_NAME = "org.eclipse.cdt.dsf.gdb.internal.ui.Messages"; //$NON-NLS-1$

	public static String GdbStatusHandler_Error;

	public static String GdbStatusHandler_Information;

	public static String GdbStatusHandler_Warning;

	static {

		// initialize resource bundle

		NLS.initializeMessages( BUNDLE_NAME, Messages.class );

	}

	private Messages() {

	}

}

GdbStatusHandler_Error=Error

GdbStatusHandler_Information=Information

GdbStatusHandler_Warning=Warning

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.eclipse.cdt.dsf.debug.internal.ui.preferences.IntegerWithBooleanFieldEditor;

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.jface.viewers.CellEditor;

import org.eclipse.jface.viewers.ColumnLabelProvider;

import org.eclipse.jface.viewers.ColumnViewer;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.EditingSupport;

import org.eclipse.jface.viewers.ICellEditorListener;

import org.eclipse.jface.viewers.ICellEditorValidator;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.jface.viewers.TextCellEditor;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.window.Window;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

	class AdvancedTimeoutSettingsDialog extends TitleAreaDialog {

		class CommandTimeoutEntry {

			String fCommand;

			Integer fTimeout;

			CommandTimeoutEntry( String command, Integer timeout ) {

				fCommand = command;

				fTimeout = timeout;

			}

		}

		class CellEditorListener implements ICellEditorListener {

			CellEditor fEditor;

			public CellEditorListener( CellEditor editor ) {

				super();

				fEditor = editor;

			}

			@Override

			public void editorValueChanged( boolean oldValidState, boolean newValidState ) {

				if ( newValidState ) {

					setErrorMessage( null );

				}

				else {

					setErrorMessage( fEditor.getErrorMessage() );

				}

				updateDialogButtons();

			}

			@Override

			public void cancelEditor() {

			}

			@Override

			public void applyEditorValue() {

				validate();

				updateDialogButtons();

			}

		};

		abstract class AbstractEditingSupport extends EditingSupport {

			public AbstractEditingSupport( ColumnViewer viewer ) {

				super( viewer );

			}

			@Override

			protected void setValue( Object element, Object value ) {

				if ( element instanceof CommandTimeoutEntry && value instanceof String ) {

					if ( processValue( (CommandTimeoutEntry)element, (String)value ) ) {

						fViewer.refresh( element );

						validate();

						updateDialogButtons();

					}

				}

			}

			@Override

			protected Object getValue( Object element ) {

				if ( element instanceof CommandTimeoutEntry ) {

					return doGetValue( (CommandTimeoutEntry)element );

				}

				return null;

			}

			@Override

			protected CellEditor getCellEditor( Object element ) {

				final CellEditor editor = new TextCellEditor( (Composite)getViewer().getControl() );

				editor.setValidator( getValidator() );

				editor.addListener( new CellEditorListener( editor ) );

				return editor;

			}

			@Override

			protected boolean canEdit( Object element ) {

				return ( element instanceof CommandTimeoutEntry );

			}

			abstract boolean processValue( CommandTimeoutEntry entry, String value );

			abstract Object doGetValue( CommandTimeoutEntry entry );

			abstract ICellEditorValidator getValidator();

		};

		private TableViewer fViewer;

		private Button fAddButton;

		private Button fDeleteButton;

		private List<CommandTimeoutEntry> fEntries;

		final private ICellEditorValidator fCommandValidator = new ICellEditorValidator() {

			@Override

			public String isValid( Object value ) {

				if ( value instanceof String && ((String)value).trim().length() == 0 ) {

					return MessagesForPreferences.GdbDebugPreferencePage_Command_field_can_not_be_empty;

				}

				return null;

			}

		};

		final private ICellEditorValidator fTimeoutValidator = new ICellEditorValidator() {

			@Override

			public String isValid( Object value ) {

				if ( value instanceof String ) {

					try {

						int intValue = Integer.decode( (String)value ).intValue();

						if ( intValue < 0 )

							return MessagesForPreferences.GdbDebugPreferencePage_Timeout_value_can_not_be_negative;

					}

					catch( NumberFormatException e ) {

						return MessagesForPreferences.GdbDebugPreferencePage_Invalid_timeout_value;

					}

				}

				return null;

			}

		};

		AdvancedTimeoutSettingsDialog( Shell parentShell, Set<Map.Entry<String, Integer>> entries ) {

			super( parentShell );

			setShellStyle(getShellStyle() | SWT.RESIZE);

			fEntries = new LinkedList<CommandTimeoutEntry>();

			for ( Map.Entry<String, Integer> entry : entries ) {

				fEntries.add( new CommandTimeoutEntry( entry.getKey(), entry.getValue() ) );

			}

		}

		/* (non-Javadoc)

		 * @see org.eclipse.jface.dialogs.TitleAreaDialog#createDialogArea(org.eclipse.swt.widgets.Composite)

		 */

		@Override

		protected Control createDialogArea( Composite parent ) {

			getShell().setText( MessagesForPreferences.GdbDebugPreferencePage_Anvanced_Timeout_Settings ); 

			setTitle( MessagesForPreferences.GdbDebugPreferencePage_Advanced_timeout_dialog_title ); 

			setTitleImage( GdbUIPlugin.getImage( IGdbUIConstants.IMG_WIZBAN_ADVANCED_TIMEOUT_SETTINGS ) );

			setMessage( MessagesForPreferences.GdbDebugPreferencePage_Advanced_timeout_dialog_message );

			Composite control = (Composite)super.createDialogArea( parent );

			Composite comp = new Composite( control, SWT.NONE );

			GridData gd = new GridData( SWT.FILL, SWT.FILL, true, true );

			comp.setLayout( new GridLayout( 2, false ) );

			comp.setLayoutData( gd );

			fViewer = new TableViewer( comp, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER );

			final Table table = fViewer.getTable();

			gd = new GridData( SWT.FILL, SWT.FILL, true, true );

			table.setLayoutData( gd );

			fViewer.addDoubleClickListener( new IDoubleClickListener() {

				@Override

				public void doubleClick( DoubleClickEvent event ) {

					okPressed();

				}

			} );

			fViewer.addSelectionChangedListener( new ISelectionChangedListener() {

				@Override

				public void selectionChanged( SelectionChangedEvent event ) {

					updateDialogButtons();

				}

			} );

			Composite btnComp = new Composite( comp, SWT.NONE );

			btnComp.setLayout( new GridLayout() );

			btnComp.setLayoutData( new GridData( SWT.RIGHT, SWT.TOP, false, false ) );

			fAddButton = new Button( btnComp, SWT.PUSH );

			fAddButton.setText( MessagesForPreferences.GdbDebugPreferencePage_Add_button );

			fAddButton.setFont( JFaceResources.getDialogFont() );

			setButtonLayoutData( fAddButton );

			fAddButton.addSelectionListener( new SelectionAdapter() {

				@Override

				public void widgetSelected( SelectionEvent e ) {

					addNewEntry();

				}

			} );

			fDeleteButton = new Button( btnComp, SWT.PUSH );

			fDeleteButton.setText( MessagesForPreferences.GdbDebugPreferencePage_Delete_button );

			fDeleteButton.setFont( JFaceResources.getDialogFont() );

			setButtonLayoutData( fDeleteButton );

			fDeleteButton.addSelectionListener( new SelectionAdapter() {

				@Override

				public void widgetSelected( SelectionEvent e ) {

					deleteEntries();

				}

			} );

			table.setLayoutData( new GridData( SWT.FILL, SWT.FILL, true, true ) );

			table.setHeaderVisible( true );

			table.setLinesVisible( true );

			TableViewerColumn commandColumn = new TableViewerColumn( fViewer, SWT.LEFT );

			commandColumn.getColumn().setText( MessagesForPreferences.GdbDebugPreferencePage_Command_column_name );

			commandColumn.setLabelProvider( createCommandLabelProvider() );

			commandColumn.setEditingSupport( createCommandEditingSupport( fViewer ) );

			TableViewerColumn timeoutColumn = new TableViewerColumn( fViewer, SWT.LEFT );

			timeoutColumn.getColumn().setText( MessagesForPreferences.GdbDebugPreferencePage_Timeout_column_name );

			timeoutColumn.setLabelProvider( createTimeoutLabelProvider() );

			timeoutColumn.setEditingSupport( createTimeoutEditingSupport( fViewer ) );

			fViewer.setContentProvider( createCustomTimeoutsContentProvider() );

			table.addControlListener( new ControlAdapter() {

				@Override

				public void controlResized( ControlEvent e ) {

					Rectangle area = table.getClientArea();

					if ( area.width > 0 ) {

						TableColumn[] cols = table.getColumns();

						cols[0].setWidth( area.width * 50 / 100 );

						cols[1].setWidth( area.width * 50 / 100 );

						table.removeControlListener( this );

					}

				}

			} );

			fViewer.setInput( fEntries );

			updateDialogButtons();

			return control;

		}

		void updateDialogButtons() {

			if ( fViewer != null && fDeleteButton != null ) {

				fDeleteButton.setEnabled( !fViewer.getSelection().isEmpty() );

			}

			Button okButton = getButton( IDialogConstants.OK_ID );

			if ( okButton != null )

				okButton.setEnabled( getErrorMessage() == null );

		}

		void addNewEntry() {

			CommandTimeoutEntry newEntry = new CommandTimeoutEntry( "", Integer.valueOf( 0 ) ); //$NON-NLS-1$

			fEntries.add( newEntry );

			fViewer.refresh();

			fViewer.setSelection( new StructuredSelection( newEntry ) );

			validateEntry( newEntry );

			updateDialogButtons();

			fViewer.editElement( newEntry, 0 );

		}

		void deleteEntries() {

			IStructuredSelection sel = (IStructuredSelection)fViewer.getSelection();

			if ( !sel.isEmpty() )

				fEntries.removeAll( sel.toList() );

			fViewer.refresh();

			validate();

			updateDialogButtons();

		}

		CustomTimeoutsMap getResult() {

			CustomTimeoutsMap map = new CustomTimeoutsMap();

			for ( CommandTimeoutEntry entry : fEntries ) {

				map.put( entry.fCommand, entry.fTimeout );

			}

			return map;

		}

		void validate() {

			for ( CommandTimeoutEntry entry : fEntries ) {

				validateEntry( entry );

			}

		}

		void validateEntry( CommandTimeoutEntry entry ) {

			String errorMessage = fCommandValidator.isValid( entry.fCommand );

			setErrorMessage( ( errorMessage != null ) ? 

					errorMessage : fTimeoutValidator.isValid( entry.fTimeout.toString() ) );

		}

		IStructuredContentProvider createCustomTimeoutsContentProvider() {

			return new IStructuredContentProvider() {

				@Override

				public void inputChanged( Viewer viewer, Object oldInput, Object newInput ) {

				}

				@Override

				public void dispose() {

				}

				@Override

				public Object[] getElements( Object inputElement ) {

					if ( inputElement instanceof List<?> ) {

						@SuppressWarnings( "unchecked" )

						List<CommandTimeoutEntry> list = (List<CommandTimeoutEntry>)inputElement;

						return list.toArray( new Object[list.size()] );

					}

					return null;

				}

			};

		}

		ColumnLabelProvider createCommandLabelProvider() {

			return new ColumnLabelProvider() {

				/* (non-Javadoc)

				 * @see org.eclipse.jface.viewers.ColumnLabelProvider#getText(java.lang.Object)

				 */

				@Override

				public String getText( Object element ) {

					if ( element instanceof CommandTimeoutEntry ) {

						return ((CommandTimeoutEntry)element).fCommand;

					}

					return super.getText( element );

				}

			};

		}

		ColumnLabelProvider createTimeoutLabelProvider() {

			return new ColumnLabelProvider() {

				/* (non-Javadoc)

				 * @see org.eclipse.jface.viewers.ColumnLabelProvider#getText(java.lang.Object)

				 */

				@Override

				public String getText( Object element ) {

					if ( element instanceof CommandTimeoutEntry ) {

						return ((CommandTimeoutEntry)element).fTimeout.toString();

					}

					return super.getText( element );

				}

			};

		}

		EditingSupport createCommandEditingSupport( ColumnViewer viewer ) {

			return new AbstractEditingSupport( viewer ) {

				@Override

				boolean processValue( CommandTimeoutEntry entry, String value ) {

					entry.fCommand = value;

					return true;

				}

				@Override

				Object doGetValue( CommandTimeoutEntry entry ) {

					return entry.fCommand;

				}

				@Override

				ICellEditorValidator getValidator() {

					return fCommandValidator;

				}

			};

		}

		EditingSupport createTimeoutEditingSupport( ColumnViewer viewer ) {

			return new AbstractEditingSupport( viewer ) {

				@Override

				boolean processValue( CommandTimeoutEntry entry, String value ) {

					try {

						entry.fTimeout = Integer.decode( value );

						return true;

					}

					catch( NumberFormatException e ) {

						// Shouldn't happen, validator takes care of this case.

					}

					return false;

				}

				@Override

				Object doGetValue( CommandTimeoutEntry entry ) {

					return entry.fTimeout.toString();

				}

				@Override

				ICellEditorValidator getValidator() {

					return fTimeoutValidator;

				}

			};

		}

	}

	private IntegerWithBooleanFieldEditor fCommandTimeoutField;

	private Button fTimeoutAdvancedButton;

	private CustomTimeoutsMap fCustomTimeouts;

		fCustomTimeouts = new CustomTimeoutsMap();

	protected void initialize() {

		super.initialize();

		initializeCustomTimeouts();

	}

	@Override

		updateTimeoutButtons();

		setButtonLayoutData( browsebutton );

		setButtonLayoutData( browsebutton );

		fCommandTimeoutField = new IntegerWithBooleanFieldEditor( 

				IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT, 

				IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT_VALUE, 

				MessagesForPreferences.GdbDebugPreferencePage_Command_timeout,

				group1);

		fCommandTimeoutField.setValidRange(1, Integer.MAX_VALUE);

		fCommandTimeoutField.fillIntoGrid(group1, 2);

		addField(fCommandTimeoutField);

		fTimeoutAdvancedButton = new Button(group1, SWT.PUSH);

		fTimeoutAdvancedButton.setText(MessagesForPreferences.GdbDebugPreferencePage_Advanced_button);

		fTimeoutAdvancedButton.addSelectionListener(new SelectionAdapter() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				handleAdvancedButtonSelected(

						"GDB Debugger");  //$NON-NLS-1$

			}

		});

		setButtonLayoutData( fTimeoutAdvancedButton );

	private void handleAdvancedButtonSelected(String dialogTitle) {

		AdvancedTimeoutSettingsDialog dialog = 

			new AdvancedTimeoutSettingsDialog( getShell(), fCustomTimeouts.entrySet() );

		if ( dialog.open() == Window.OK ) {

			fCustomTimeouts = dialog.getResult();

		}

	}

	@Override

	public void propertyChange( PropertyChangeEvent event ) {

		if ( event.getSource().equals( fCommandTimeoutField ) && event.getNewValue() instanceof Boolean ) {

			fTimeoutAdvancedButton.setEnabled( ((Boolean)event.getNewValue()).booleanValue() );

		}

		super.propertyChange( event );

	}

	@Override

	protected void performDefaults() {

		IPreferenceStore store = getPreferenceStore();

		if ( store != null ) {

			String memento = store.getDefaultString( IGdbDebugPreferenceConstants.PREF_COMMAND_CUSTOM_TIMEOUTS );

			fCustomTimeouts.initializeFromMemento( memento );

		}

		super.performDefaults();

		updateTimeoutButtons();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.preference.FieldEditorPreferencePage#performOk()

	 */

	@Override

	public boolean performOk() {

		getPreferenceStore().setValue( IGdbDebugPreferenceConstants.PREF_COMMAND_CUSTOM_TIMEOUTS, fCustomTimeouts.getMemento() );

		return super.performOk();

	}

	private void updateTimeoutButtons() {

		fTimeoutAdvancedButton.setEnabled( fCommandTimeoutField.getBooleanValue() );

	}

	private void initializeCustomTimeouts() {

		IPreferenceStore store = getPreferenceStore();

		if ( store != null ) {

			String memento = store.getString( IGdbDebugPreferenceConstants.PREF_COMMAND_CUSTOM_TIMEOUTS );

			fCustomTimeouts.initializeFromMemento( memento );

		}

	}

	public static String GdbDebugPreferencePage_Add_button;

	public static String GdbDebugPreferencePage_Advanced_button;

	public static String GdbDebugPreferencePage_Advanced_timeout_dialog_message;

	public static String GdbDebugPreferencePage_Advanced_timeout_dialog_title;

	public static String GdbDebugPreferencePage_Anvanced_Timeout_Settings;

	public static String GdbDebugPreferencePage_Command_column_name;

	public static String GdbDebugPreferencePage_Command_field_can_not_be_empty;

	public static String GdbDebugPreferencePage_Command_timeout;

	public static String GdbDebugPreferencePage_Delete_button;

	public static String GdbDebugPreferencePage_Invalid_timeout_value;

	public static String GdbDebugPreferencePage_Timeout_column_name;

	public static String GdbDebugPreferencePage_Timeout_value_can_not_be_negative;

GdbDebugPreferencePage_Add_button=Add

GdbDebugPreferencePage_Command_column_name=GDB/MI Command

GdbDebugPreferencePage_Command_field_can_not_be_empty='Command' field can not be empty

GdbDebugPreferencePage_Command_timeout=Command timeout (ms):

GdbDebugPreferencePage_Delete_button=Delete

GdbDebugPreferencePage_Invalid_timeout_value=Invalid timeout value

GdbDebugPreferencePage_Timeout_column_name=Timeout(ms)

GdbDebugPreferencePage_Timeout_value_can_not_be_negative=Timeout value can not be negative

GdbDebugPreferencePage_Advanced_button=&Advanced...

GdbDebugPreferencePage_Advanced_timeout_dialog_message=Specify commands and corresponding timeout values, '0' for 'no timeout'.\nAll commands that are not mentioned here will get the default timeout value.

GdbDebugPreferencePage_Advanced_timeout_dialog_title=Add/delete/modify custom timeouts for GDB/MI commands

GdbDebugPreferencePage_Anvanced_Timeout_Settings=Advanced Timeout Settings

org.eclipse.cdt.dsf.gdb/debug/timeouts = false

	/**

	 * Status code for which a UI handler is registered.

	 * @since 4.1

	 */

	public static final int STATUS_HANDLER_CODE = 20001;

	 * The value is an boolean specifying whether the timeout is used for GDB commands.

	 * @since 4.1

	 */

	public static final String PREF_COMMAND_TIMEOUT = "commandTimeout"; //$NON-NLS-1$

	/**

	 * The value is an integer specifying the timeout value (milliseconds) for GDB commands.

	 * @since 4.1

	 */

	public static final String PREF_COMMAND_TIMEOUT_VALUE = "commandTimeoutValue"; //$NON-NLS-1$

	/**

	 * The value is a string specifying the list of GDB/MI commands with custom timeout values.

	 * @since 4.1

	 */

	public static final String PREF_COMMAND_CUSTOM_TIMEOUTS = "commandTimeoutSpecials"; //$NON-NLS-1$

	/**

	 * Default default value for <code>PREF_COMMAND_TIMEOUT</code>;

	 * @since 4.1

	 */

	public static final int COMMAND_TIMEOUT_VALUE_DEFAULT = 10000;

	/**

		node.putBoolean(IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT, false);

		node.putInt(IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT_VALUE, IGdbDebugPreferenceConstants.COMMAND_TIMEOUT_VALUE_DEFAULT);

/*******************************************************************************

 * Copyright (c) 2011 Mentor Graphics 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:

 * Mentor Graphics - Initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.internal;

import org.eclipse.osgi.util.NLS;

public class Messages extends NLS {

	private static final String BUNDLE_NAME = "org.eclipse.cdt.dsf.gdb.internal.Messages"; //$NON-NLS-1$

	public static String DefaultGdbCommandTimeoutPolicy_Session_is_terminated;

	static {

		// initialize resource bundle

		NLS.initializeMessages( BUNDLE_NAME, Messages.class );

	}

	private Messages() {

	}

}

#######################################################################################

# Copyright (c) 2011 Mentor Graphics 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:

# Mentor Graphics - Initial API and implementation

#######################################################################################

DefaultGdbCommandTimeoutPolicy_Session_is_terminated=Session is terminated.\nReason: %s

import org.eclipse.cdt.dsf.gdb.service.command.IGdbCommandTimeoutService.ICommandTimedOutDMEvent;

    /**

	 * @since 4.1

	 */

    @DsfServiceEventHandler 

    public void eventDispatched(ICommandTimedOutDMEvent event) {

        shutdownSession(new RequestMonitor(ImmediateExecutor.getInstance(), null));

    }

import org.eclipse.cdt.dsf.debug.service.IStack;

import org.eclipse.cdt.dsf.gdb.service.command.IGdbCommandTimeoutService;

        new Step() { @Override

        public void execute(RequestMonitor requestMonitor) {

           	IGdbCommandTimeoutService timeoutService = fLaunch.getServiceFactory().createService(IGdbCommandTimeoutService.class, fSession);

           	// Note that for older versions of GDB, we don't support tracing, so there is no trace service.

           	if (timeoutService != null) {

           		timeoutService.initialize(requestMonitor);

           	} else {

           		requestMonitor.done();

           	}

        }},

import org.eclipse.cdt.dsf.gdb.service.command.GdbCommandTimeoutService;

import org.eclipse.cdt.dsf.gdb.service.command.IGdbCommandTimeoutService;

		}

		else if (IGdbCommandTimeoutService.class.isAssignableFrom(clazz)) {

			return (V)createCommandTimeoutService(session);

	/**

	 * @since 4.1

	 */

	protected IGdbCommandTimeoutService createCommandTimeoutService(DsfSession session) {

		return new GdbCommandTimeoutService(session);

	}

/*******************************************************************************

 * Copyright (c) 2011 Mentor Graphics 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:

 * Mentor Graphics - Initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.service.command;

import java.util.HashMap;

import java.util.Map;

import java.util.StringTokenizer;

import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.MultiStatus;

import org.eclipse.core.runtime.Status;

/**

 * @since 4.1

 */

public class CustomTimeoutsMap extends HashMap<String, Integer> {

	public CustomTimeoutsMap() {

		super();

	}

	public CustomTimeoutsMap( CustomTimeoutsMap map ) {

		super( map );

	}

	private static final long serialVersionUID = -8281280275781904870L;

	public String getMemento() {

		StringBuilder sb = new StringBuilder();

		for ( Map.Entry<String, Integer> entry : entrySet() ) {

			sb.append( entry.getKey() );

			sb.append( ',' );

			sb.append( entry.getValue().intValue() );

			sb.append( ';' );

		}

		return sb.toString();

	}

	public void initializeFromMemento( String memento ) {

		clear();

		StringTokenizer st = new StringTokenizer( memento, ";" ); //$NON-NLS-1$

		MultiStatus ms = new MultiStatus( GdbPlugin.PLUGIN_ID, 0, "Error initializing custom timeouts", null );

		while( st.hasMoreTokens() ) {

			String token = st.nextToken();

			String[] tokenParts = token.split( "," ); //$NON-NLS-1$

			if ( tokenParts.length == 2 && tokenParts[0].length() > 0 && tokenParts[0].length() > 0 ) {

				try {

					put( tokenParts[0], Integer.valueOf( tokenParts[1] ) );

				}

				catch( NumberFormatException e ) {

					ms.add( new Status(

							IStatus.ERROR, 

							GdbPlugin.PLUGIN_ID, 

							String.format( "Invalid custom timeout value for '%s'.", tokenParts[0] ) ) );

				}

			}

			else {

				ms.add( new Status(

						IStatus.ERROR, 

						GdbPlugin.PLUGIN_ID, 

						"Invalid custom timeout data." ) );

			}

		}

		if ( !ms.isOK() ) {

			GdbPlugin.getDefault().getLog().log( ms );

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2011 Mentor Graphics 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:

 * Mentor Graphics - Initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.service.command;

import org.eclipse.cdt.dsf.concurrent.DsfRunnable;

import org.eclipse.cdt.dsf.concurrent.RequestMonitor;

import org.eclipse.cdt.dsf.debug.service.command.ICommandToken;

import org.eclipse.cdt.dsf.gdb.IGdbDebugConstants;

import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;

import org.eclipse.cdt.dsf.gdb.internal.Messages;

import org.eclipse.cdt.dsf.mi.service.command.AbstractMIControl;

import org.eclipse.cdt.dsf.service.DsfServicesTracker;

import org.eclipse.cdt.dsf.service.DsfSession;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.debug.core.DebugPlugin;

import org.eclipse.debug.core.IStatusHandler;

/**

 * Default implementation of the command timeout policy.

 * If a command is timed out it sets the command's status to 

 * 'error' and terminate the session.

 *  

 * @since 4.1

 */

public class DefaultGdbCommandTimeoutPolicy implements ICommandTimeoutPolicy {

	private DsfSession fSession;

	private AbstractMIControl fCommandControl;

	public DefaultGdbCommandTimeoutPolicy( DsfSession session, AbstractMIControl commandControl ) {

		super();

		fSession = session;

		fCommandControl = commandControl;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.gdb.service.command.ICommandTimeoutPolicy#commandTimedOut(org.eclipse.cdt.dsf.debug.service.command.ICommandToken)

	 */

	@Override

	public void commandTimedOut( ICommandToken token ) {

		String commandText = token.getCommand().toString();

		if ( commandText.endsWith( "\n" ) ) //$NON-NLS-1$

			commandText = commandText.substring( 0, commandText.length() - 1 );

		final String errorMessage = String.format( "Command '%s' is timed out", commandText ); //$NON-NLS-1$

		fCommandControl.commandFailed( token, errorMessage );

		fSession.getExecutor().execute( new DsfRunnable() {

			@Override

			public void run() {

				DsfServicesTracker tracker = new DsfServicesTracker( GdbPlugin.getBundleContext(), fSession.getId() );

				IGDBControl gdbControl = tracker.getService( IGDBControl.class );

				tracker.dispose();

				if ( gdbControl != null ) {

					gdbControl.terminate( new RequestMonitor( fSession.getExecutor(), null ) {

						@Override

						protected void handleErrorOrWarning() {

							GdbPlugin.getDefault().getLog().log( getStatus() );

							super.handleErrorOrWarning();

						};

					} );

					// If the timeout occurs while the launch sequence is being executed the error 

					// will be reported using the launcher's error reporting mechanism.

					if ( fCommandControl instanceof IGDBControlExtension 

							&& ((IGDBControlExtension)fCommandControl).isInitialized() ) {

						IStatus status = new Status( 

								IStatus.ERROR, 

								GdbPlugin.PLUGIN_ID, 

								IGdbDebugConstants.STATUS_HANDLER_CODE, 

								String.format( Messages.DefaultGdbCommandTimeoutPolicy_Session_is_terminated, errorMessage ), 

								null );

						IStatusHandler statusHandler = DebugPlugin.getDefault().getStatusHandler( status );

						if ( statusHandler != null ) {

							try {

								statusHandler.handleStatus( status, null );

							}

							catch( CoreException e ) {

								GdbPlugin.getDefault().getLog().log( e.getStatus() );

							}

						}

					}

				}

			}

		} );

	}

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.gdb.service.command.ICommandTimeoutPolicy#dispose()

	 */

	@Override

	public void dispose() {

	}

	protected DsfSession getSession() {

		return fSession;

	}

	protected AbstractMIControl getCommandControl() {

		return fCommandControl;

	}

}

import org.eclipse.core.runtime.IProgressMonitor;

    private Sequence fInitializationSequence;

    private boolean fInitialized = false;

	/**

	 * @since 4.1

	 */

	@Override

	public boolean isInitialized() {

		return fInitialized;

	}

import org.eclipse.core.runtime.IProgressMonitor;

    private Sequence fInitializationSequence;

    private boolean fInitialized = false;

	/**

	 * @since 4.1

	 */

	@Override

	public boolean isInitialized() {

		return fInitialized;

	}

/*******************************************************************************

 * Copyright (c) 2011 Mentor Graphics 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:

 * Mentor Graphics - Initial API and implementation

 *******************************************************************************/

package org.eclipse.cdt.dsf.gdb.service.command;

import java.util.Hashtable;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;

import org.eclipse.cdt.dsf.concurrent.RequestMonitor;

import org.eclipse.cdt.dsf.datamodel.AbstractDMEvent;

import org.eclipse.cdt.dsf.debug.service.command.ICommand;

import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlDMContext;

import org.eclipse.cdt.dsf.debug.service.command.ICommandResult;

import org.eclipse.cdt.dsf.debug.service.command.ICommandToken;

import org.eclipse.cdt.dsf.gdb.IGdbDebugPreferenceConstants;

import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;

import org.eclipse.cdt.dsf.mi.service.command.AbstractMIControl;

import org.eclipse.cdt.dsf.mi.service.command.commands.MICommand;

import org.eclipse.cdt.dsf.mi.service.command.output.MIInfo;

import org.eclipse.cdt.dsf.service.AbstractDsfService;

import org.eclipse.cdt.dsf.service.DsfSession;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.preferences.IEclipsePreferences;

import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;

import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;

import org.eclipse.core.runtime.preferences.InstanceScope;

import org.osgi.framework.BundleContext;

/**

 * Command timeout service. Registers itself as a command listener and monitors 

 * the execution time. If the execution of a command takes more time than expected 

 * the service activates the timeout policy {@link ICommandTimeoutPolicy}.

 *    

 * @since 4.1

 */

public class GdbCommandTimeoutService extends AbstractDsfService implements IGdbCommandTimeoutService, IPreferenceChangeListener {

	public final static boolean DEBUG = "true".equals( Platform.getDebugOption( "org.eclipse.cdt.dsf.gdb/debug/timeouts" ) ); //$NON-NLS-1$//$NON-NLS-2$

	class CommandTimedOutDMEvent extends AbstractDMEvent<ICommandControlDMContext> implements ICommandTimedOutDMEvent {

		private ICommandToken fCommandToken;

		CommandTimedOutDMEvent( ICommandControlDMContext context, ICommandToken commandToken ) {

			super( context );

			fCommandToken = commandToken;

		}

		/* (non-Javadoc)

		 * @see org.eclipse.cdt.dsf.gdb.service.command.IGdbCommandTimeoutService.ICommandTimedOutDMEvent#getCommand()

		 */

		@Override

		public ICommandToken getCommand() {

			return fCommandToken;

		}

	}

	class QueueEntry {

		long fTimestamp;

		ICommandToken fCommandToken;

		QueueEntry( long timestamp, ICommandToken commandToken ) {

			super();

			fTimestamp = timestamp;

			fCommandToken = commandToken;

		}

		/* (non-Javadoc)

		 * @see java.lang.Object#equals(java.lang.Object)

		 */

		@Override

		public boolean equals( Object obj ) {

			// We purposely ignore the timestamp here to make the removing 

			// of a command token from the queue simple.

			// See org.eclipse.cdt.dsf.gdb.service.command.GdbCommandTimeoutService#commandRemoved()

			// and org.eclipse.cdt.dsf.gdb.service.command.GdbCommandTimeoutService#commandDone().

			if ( obj instanceof QueueEntry ) {

				return fCommandToken.equals( ((QueueEntry)obj).fCommandToken );

			}

			return false;

		}

	}

	enum TimerThreadState {

		INITIALIZING,

		RUNNING,

		HALTED,

		SHUTDOWN

	}

	/**

	 *

	 */

	class TimerThread extends Thread {

		private BlockingQueue<QueueEntry> fQueue;

		private int fWaitTimeout = IGdbDebugPreferenceConstants.COMMAND_TIMEOUT_VALUE_DEFAULT;

		private TimerThreadState fState = TimerThreadState.INITIALIZING;

		TimerThread( BlockingQueue<QueueEntry> queue, int timeout ) {

			super();

			fQueue = queue;

			setWaitTimout( timeout );

		}

		/* (non-Javadoc)

		 * @see java.lang.Thread#run()

		 */

		@Override

		public void run() {

			setState( ( getWaitTimeout() > 0 ) ? 

					TimerThreadState.RUNNING : TimerThreadState.HALTED );

			doRun();

		}

		private void doRun() {

			if ( fState == TimerThreadState.HALTED ) {

				halted();

			}

			else {

				running();

			}

		}

		private void halted() {

			try {

				synchronized( TimerThread.this ) {

					wait();

				}

			}

			catch( InterruptedException e ) {

				doRun();

			}

		}

		private void running() {

			try {

				while( fState == TimerThreadState.RUNNING ) {

					long timeout = getWaitTimeout();

					QueueEntry entry = fQueue.peek();

					if ( entry != null ) {

						// Calculate the time elapsed since the execution of this command started 

						// and compare it with the command's timeout value.

						// If the elapsed time is greater or equal than the timeout value the command 

						// is marked as timed out. Otherwise, schedule the next check when the timeout 

						// expires.

						long commandTimeout = getTimeoutForCommand( entry.fCommandToken.getCommand() );

						if ( DEBUG ) {

							String commandText = entry.fCommandToken.getCommand().toString();

							if ( commandText.endsWith( "\n" ) ) //$NON-NLS-1$

								commandText = commandText.substring( 0, commandText.length() - 1 );

							printDebugMessage( String.format( "Processing command '%s', command timeout is %d", //$NON-NLS-1$ 

									commandText, Long.valueOf( commandTimeout ) ) );

						}

						long elapsedTime = System.currentTimeMillis() - entry.fTimestamp;

						if ( commandTimeout <= elapsedTime ) {

							processTimedOutCommand( entry.fCommandToken );

							fQueue.remove( entry );

						}

						else {

							timeout = Math.min( timeout, commandTimeout - elapsedTime );

							if ( DEBUG ) {

								String commandText = entry.fCommandToken.getCommand().toString();

								if ( commandText.endsWith( "\n" ) ) //$NON-NLS-1$

									commandText = commandText.substring( 0, commandText.length() - 1 );

								printDebugMessage( String.format( "Setting timeout %d for command '%s'", Long.valueOf( timeout ), commandText ) ); //$NON-NLS-1$

							}

						}

					}

					synchronized( TimerThread.this ) {

						wait( timeout );

					}

					if ( isInterrupted() ) {

						doRun();

					}

				}

			}

			catch( InterruptedException e ) {

				doRun();

			}

		}

		void shutdown() {

			setState( TimerThreadState.SHUTDOWN );

			interrupt();

		}

		void haltProcessing() {

			setState( TimerThreadState.HALTED );