<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(0, 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'.\nThe default value will be used for all commands that are not mentioned here.

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 CustomTimeoutsMap_Error_initializing_custom_timeouts;

	public static String CustomTimeoutsMap_Invalid_custom_timeout_data;

	public static String CustomTimeoutsMap_Invalid_custom_timeout_value;

	public static String GDBControl_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

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

CustomTimeoutsMap_Error_initializing_custom_timeouts=Error initializing custom timeouts

CustomTimeoutsMap_Invalid_custom_timeout_data=Invalid custom timeout data.

CustomTimeoutsMap_Invalid_custom_timeout_value=Invalid custom timeout value for '%s'.

GDBControl_Session_is_terminated=Session is terminated.\nReason: %s

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

 * 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.cdt.dsf.gdb.internal.Messages;

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, Messages.CustomTimeoutsMap_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( Messages.CustomTimeoutsMap_Invalid_custom_timeout_value, tokenParts[0] ) ) );

				}

			}

			else {

				ms.add( new Status(

						IStatus.ERROR, 

						GdbPlugin.PLUGIN_ID, 

						Messages.CustomTimeoutsMap_Invalid_custom_timeout_data ) );

			}

		}

		if ( !ms.isOK() ) {

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

		}

	}

}

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

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

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

import org.eclipse.cdt.dsf.gdb.service.command.GdbCommandTimeoutManager.ICommandTimeoutListener;

import org.eclipse.debug.core.DebugPlugin;

import org.eclipse.debug.core.IStatusHandler;

	private static final int STATUS_CODE_COMMAND_TIMED_OUT = 20100;

	private class TimeoutListener implements ICommandTimeoutListener {

		@Override

		public void commandTimedOut( ICommandToken token ) {

			GDBControl.this.commandTimedOut(token);

		}		

	}

    private GdbCommandTimeoutManager fCommandTimeoutManager;

    private ICommandTimeoutListener fTimeoutListener = new TimeoutListener();

	private boolean fInitialized = false;

				fInitialized = true;

    /**

	 * @since 4.1

	 */

    protected class CommandTimeoutStep extends InitializationShutdownStep {

		CommandTimeoutStep( Direction direction ) {

			super( direction );

		}

		@Override

		public void initialize( final RequestMonitor requestMonitor ) {

			fCommandTimeoutManager = createCommandTimeoutManager( GDBControl.this );

			if (fCommandTimeoutManager != null) {

				fCommandTimeoutManager.addCommandTimeoutListener(fTimeoutListener);

			}

			requestMonitor.done();

		}

		@Override

		protected void shutdown( RequestMonitor requestMonitor ) {

			if ( fCommandTimeoutManager != null ) {

				fCommandTimeoutManager.removeCommandTimeoutListener(fTimeoutListener);

				fCommandTimeoutManager.dispose();

			}

			requestMonitor.done();

		}

	}

                new CommandTimeoutStep(InitializationShutdownStep.Direction.INITIALIZING),

                new CommandTimeoutStep(InitializationShutdownStep.Direction.SHUTTING_DOWN),

	/**

	 * @since 4.1

	 */

	protected GdbCommandTimeoutManager createCommandTimeoutManager(IGDBControl commandControl) {

		GdbCommandTimeoutManager manager = new GdbCommandTimeoutManager(commandControl);

		manager.initialize();

		return manager;

	}

	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$

		commandFailed(token, STATUS_CODE_COMMAND_TIMED_OUT, errorMessage);

		// If the timeout occurs while the launch sequence is running 

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

		// We need to show the error message only when the session is initialized.

		if (fInitializationSequence == null && fInitialized) {

			getExecutor().execute(new DsfRunnable() {

				@Override

				public void run() {

					terminate(new RequestMonitor(getExecutor(), null) {

						@Override

						protected void handleErrorOrWarning() {

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

							super.handleErrorOrWarning();

						};

					} );

					IStatus status = new Status( 

							IStatus.ERROR, 

							GdbPlugin.PLUGIN_ID, 

							IGdbDebugConstants.STATUS_HANDLER_CODE, 

							String.format( Messages.GDBControl_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());

						}

					}

				}

			} );

		}	

	}

                new CommandTimeoutStep(GDBControl.InitializationShutdownStep.Direction.INITIALIZING),

                new CommandTimeoutStep(GDBControl.InitializationShutdownStep.Direction.SHUTTING_DOWN),

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

 * 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.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

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

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

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.core.runtime.IStatus;

import org.eclipse.core.runtime.ListenerList;

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;

/**

 * The command timeout manager registers itself as a command listener and monitors 

 * the command execution time. The goal of this implementation is to gracefully 

 * handle disruptions in the communication between Eclipse and GDB. 

 * 

 * The algorithm used by this class is based on the assumption that the command 

 * execution in GDB is sequential even though DSF can send up to 3 commands at 

 * a time to GDB (see {@link AbstractMIControl}).

 *  

 * @since 4.1

 */

public class GdbCommandTimeoutManager implements ICommandListener, IPreferenceChangeListener {

	public interface ICommandTimeoutListener {

		void commandTimedOut( ICommandToken token );

	}

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

	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 ) {

			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 currentTime = System.currentTimeMillis();

						long elapsedTime = currentTime - entry.fTimestamp;

						if ( commandTimeout <= elapsedTime ) {

							processTimedOutCommand( entry.fCommandToken );

							fQueue.remove( entry );

							// Reset the timestamp of the next command in the queue because 

							// regardless how long the command has been in the queue GDB will 

							// start executing it only when the previous command is . 

							QueueEntry nextEntry = fQueue.peek();

							if ( nextEntry != null ) {

								setTimeStamp( currentTime, nextEntry );

							}

						}

						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 );

			interrupt();

		}

		void resumeProcessing() {

			setState( TimerThreadState.RUNNING );

			interrupt();

		}

		void setWaitTimout( int waitTimeout ) {

			fWaitTimeout = waitTimeout;

			if ( DEBUG )

				printDebugMessage( String.format( "Wait timeout is set to %d", Integer.valueOf( fWaitTimeout ) ) ); //$NON-NLS-1$

		}

		int getWaitTimeout() {

			return fWaitTimeout;

		}

		void setState( TimerThreadState state ) {

			fState = state;

		}

	}

	private static final String TIMEOUT_TRACE_IDENTIFIER = "[TMO]"; //$NON-NLS-1$

	private IGDBControl fCommandControl;

	private boolean fTimeoutEnabled = false;

	private int fTimeout = 0;

	private TimerThread fTimerThread;

	private BlockingQueue<QueueEntry> fCommandQueue = new LinkedBlockingQueue<QueueEntry>();

	private CustomTimeoutsMap fCustomTimeouts = new CustomTimeoutsMap();

	private ListenerList fListeners;

	public GdbCommandTimeoutManager( IGDBControl commandControl ) {

		fCommandControl = commandControl;

		fListeners = new ListenerList();

	}

	public void initialize() {

		IEclipsePreferences node = InstanceScope.INSTANCE.getNode( GdbPlugin.PLUGIN_ID );

		fTimeoutEnabled = Platform.getPreferencesService().getBoolean( 

				GdbPlugin.PLUGIN_ID,

				IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT, 

				false,

				null );

		fTimeout = Platform.getPreferencesService().getInt( 

				GdbPlugin.PLUGIN_ID,

				IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT_VALUE, 

				IGdbDebugPreferenceConstants.COMMAND_TIMEOUT_VALUE_DEFAULT,

				null );

		fCustomTimeouts.initializeFromMemento( Platform.getPreferencesService().getString( 

				GdbPlugin.PLUGIN_ID,

				IGdbDebugPreferenceConstants.PREF_COMMAND_CUSTOM_TIMEOUTS, 

				"", //$NON-NLS-1$

				null ) );

		node.addPreferenceChangeListener( this );

		fCommandControl.addCommandListener( this );

		fTimerThread = new TimerThread( fCommandQueue, calculateWaitTimeout() );

		fTimerThread.start();

	}

	public void dispose() {

		fTimerThread.shutdown();

		fListeners.clear();

		InstanceScope.INSTANCE.getNode( GdbPlugin.PLUGIN_ID ).removePreferenceChangeListener( this );

		fCommandControl.removeCommandListener( this );

		fCommandQueue.clear();

		fCustomTimeouts.clear();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.debug.service.command.ICommandListener#commandQueued(org.eclipse.cdt.dsf.debug.service.command.ICommandToken)

	 */

	@Override

	public void commandQueued( ICommandToken token ) {

	}

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.debug.service.command.ICommandListener#commandSent(org.eclipse.cdt.dsf.debug.service.command.ICommandToken)

	 */

	@Override

	public void commandSent( ICommandToken token ) {

		if ( !isTimeoutEnabled() )

			return;

		int commandTimeout = getTimeoutForCommand( token.getCommand() );

		if ( DEBUG ) {

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

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

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

			printDebugMessage( String.format( "Command '%s' sent, timeout = %d", commandText, Integer.valueOf( commandTimeout ) ) ); //$NON-NLS-1$

		}

		if ( commandTimeout == 0 )

			// Skip commands with no timeout 

			return;

		try {

			fCommandQueue.put( new QueueEntry( System.currentTimeMillis(), token ) );

		}

		catch( InterruptedException e ) {

			// ignore

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.debug.service.command.ICommandListener#commandRemoved(org.eclipse.cdt.dsf.debug.service.command.ICommandToken)

	 */

	@Override

	public void commandRemoved( ICommandToken token ) {

		if ( !isTimeoutEnabled() )

			return;

		removeCommand( token, false );

	}

	/* (non-Javadoc)

	 * @see org.eclipse.cdt.dsf.debug.service.command.ICommandListener#commandDone(org.eclipse.cdt.dsf.debug.service.command.ICommandToken, org.eclipse.cdt.dsf.debug.service.command.ICommandResult)

	 */

	@Override

	public void commandDone( ICommandToken token, ICommandResult result ) {

		if ( !isTimeoutEnabled() )

			return;

		removeCommand( token, true );

	}

	/* (non-Javadoc)

	 * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)

	 */

	@Override

	public void preferenceChange( PreferenceChangeEvent event ) {

		String property = event.getKey();

		if ( IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT.equals( property ) ) {

			if ( event.getNewValue() == null || !event.getNewValue().equals( event.getOldValue() ) ) {

				fTimeoutEnabled = Boolean.parseBoolean( event.getNewValue().toString() );

				updateWaitTimeout();

				fTimerThread.setState( ( fTimerThread.getWaitTimeout() > 0 ) ? 

						TimerThreadState.RUNNING : TimerThreadState.HALTED );

				fTimerThread.interrupt();

			}

		}

		else if ( IGdbDebugPreferenceConstants.PREF_COMMAND_TIMEOUT_VALUE.equals( property ) ) {

			if ( !event.getNewValue().equals( event.getOldValue() ) ) {

				try {

					fTimeout = Integer.parseInt( event.getNewValue().toString() );

					updateWaitTimeout();

					fTimerThread.setState( ( fTimerThread.getWaitTimeout() > 0 ) ? 

							TimerThreadState.RUNNING : TimerThreadState.HALTED );

					fTimerThread.interrupt();

				}

				catch( NumberFormatException e ) {

					GdbPlugin.getDefault().getLog().log( new Status( IStatus.ERROR, GdbPlugin.PLUGIN_ID, "Invlaid timeout value" ) ); //$NON-NLS-1$

				}

			}

		}

		else if ( IGdbDebugPreferenceConstants.PREF_COMMAND_CUSTOM_TIMEOUTS.equals( property ) ) {

			if ( event.getNewValue() instanceof String ) {

				fCustomTimeouts.initializeFromMemento( (String)event.getNewValue() );

			}

			else if ( event.getNewValue() == null ) {

				fCustomTimeouts.clear();

			}

			updateWaitTimeout();

			fTimerThread.setState( ( fTimerThread.getWaitTimeout() > 0 ) ? 

					TimerThreadState.RUNNING : TimerThreadState.HALTED );

			fTimerThread.interrupt();

		}

	}

	protected int getTimeoutForCommand( ICommand<? extends ICommandResult> command ) {

		if ( !(command instanceof MICommand<?>) )

			return 0;

		@SuppressWarnings( "unchecked" )

		Integer timeout = fCustomTimeouts.get( ((MICommand<? extends MIInfo>)command).getOperation() );

		return ( timeout != null ) ? timeout.intValue() : fTimeout;

	}

	protected void processTimedOutCommand( ICommandToken token ) {

		if ( DEBUG ) {

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

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

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

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