org.eclipse.debug.core.DebugException Java Examples

public boolean equals( Object obj )
{
	if ( obj instanceof ScriptStackFrame )
	{
		ScriptStackFrame sf = (ScriptStackFrame) obj;
		try
		{
			return sf.getName( ).equals( getName( ) )
					&& sf.getLineNumber( ) == getLineNumber( )
					&& sf.id == id;
		}
		catch ( DebugException e )
		{
			//donothing
		}
	}
	return false;
}
 

/**
 * Waits until {@code launch} terminates or {@code monitor} is canceled. if the monitor is
 * canceled, attempts to terminate the launch before returning.
 *
 * @return true if the launch terminated normally; false otherwise
 */
@VisibleForTesting
static boolean waitUntilLaunchTerminates(ILaunch launch, IProgressMonitor monitor)
    throws InterruptedException, DebugException {
  while (!launch.isTerminated() && !monitor.isCanceled()) {
    Thread.sleep(100 /*ms*/);
  }

  if (monitor.isCanceled()) {
    launch.terminate();
    return false;
  }
  for (IProcess process : launch.getProcesses()) {
    if (process.getExitValue() != 0) {
      return false;
    }
  }
  return true;
}
 

public String getName( ) throws DebugException
{
	if ( name == null )
	{
		name = getDefaultName( );
		try
		{
			name = getLaunch( ).getLaunchConfiguration( )
					.getAttribute( IScriptConstants.ATTR_REPORT_PROGRAM,
							name );
		}
		catch ( CoreException e )
		{
		}
	}
	return renderState( ) + name;
}
 

public String findXtextSourceFileNameForClassFile(String simpleFileName) {
	if (!simpleFileName.endsWith(".class"))
		return null;
	String typename = simpleFileName.substring(0, simpleFileName.length() - ".class".length());
	synchronized (this) {
		try {
			List<IStackFrame> frames = Lists.newArrayList();
			if (lastFrame != null)
				frames.add(lastFrame);
			if (lastThread != null)
				frames.addAll(Lists.newArrayList(lastThread.getStackFrames()));
			for (IStackFrame frame : frames)
				if (frame instanceof IJavaStackFrame) {
					IJavaStackFrame jsf = (IJavaStackFrame) frame;
					String simpleName = Strings.lastToken(jsf.getDeclaringTypeName(), ".");
					if (simpleName.equals(typename))
						return jsf.getSourceName();
				}
		} catch (DebugException e) {
			log.error(e.getMessage(), e);
		}
		return null;
	}

}
 

@Override
public void serverChanged(ServerEvent event) {
  Preconditions.checkState(server == event.getServer());
  switch (event.getState()) {
    case IServer.STATE_STARTED:
      openBrowserPage(server);
      fireChangeEvent(DebugEvent.STATE);
      return;

    case IServer.STATE_STOPPED:
      server.removeServerListener(serverEventsListener);
      fireTerminateEvent();
      try {
        logger.fine("Server stopped; terminating launch"); //$NON-NLS-1$
        launch.terminate();
      } catch (DebugException ex) {
        logger.log(Level.WARNING, "Unable to terminate launch", ex); //$NON-NLS-1$
      }
      checkUpdatedDatastoreIndex(launch.getLaunchConfiguration());
      return;

    default:
      fireChangeEvent(DebugEvent.STATE);
      return;
  }
}
 

public static void terminateAllLaunchConfigs(SWTBot bot) {
  SwtBotUtils.print("Terminating Launches");

  ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
  ILaunch[] launches = manager.getLaunches();
  if (launches == null || launches.length == 0) {
    SwtBotUtils.print("No Launches to terminate");
  }

  for (ILaunch launch : launches) {
    if (!launch.isTerminated()) {
      try {
        launch.terminate();
      } catch (DebugException e) {
        SwtBotUtils.printError("Could not terminate launch." + e.getMessage());
      }
    }
  }

  SwtBotWorkbenchActions.waitForIdle(bot);

  SwtBotUtils.print("Terminated Launches");
}
 

@Override
protected RGB getRGB(IVariable variable) throws DebugException {
	IJavaValue v = (IJavaValue) variable.getValue();
	if ("org.eclipse.swt.graphics.RGB".equals(v.getJavaType().toString())) {
		Integer red = null, blue = null, green = null;
		for (IVariable field : v.getVariables()) {
			if ("red".equals(field.getName().toString())) {
				red = Integer.parseInt(field.getValue().getValueString());
			} else if ("green".equals(field.getName().toString())) {
				green = Integer.parseInt(field.getValue().getValueString());
			} else if ("blue".equals(field.getName().toString())) {
				blue = Integer.parseInt(field.getValue().getValueString());
			}
		}
		if (red != null && green != null && blue != null) {
			return new RGB(red, green, blue);
		}
	}
	return null;
}
 

/**
 * Gets the expression display name
 * 
 * @param expression
 * @return
 * @throws DebugException
 */
private String getExpressionText( IExpression expression )
		throws DebugException
{
	StringBuffer buff = new StringBuffer( );
	IValue javaValue = expression.getValue( );

	buff.append( '"' + expression.getExpressionText( ) + '"' );

	if ( javaValue != null )
	{
		String valueString = getValueText( javaValue );
		if ( valueString.length( ) > 0 )
		{
			buff.append( "= " ); //$NON-NLS-1$
			buff.append( valueString );
		}
	}
	return buff.toString( );
}
 

@Override
public void run() {
	Display.getDefault().asyncExec(new Runnable() {

		@Override
		public void run() {
			IDebugTarget[] debugTargets = debugTarget.getLaunch().getDebugTargets();
			for (IDebugTarget current : debugTargets) {
				if (current instanceof IStep) {
					try {
						((IStep) current).stepOver();
					} catch (DebugException e) {
						e.printStackTrace();
					}
				}
			}
		}
	});
}
 

@Override
public void run() {
	Display.getDefault().asyncExec(new Runnable() {

		@Override
		public void run() {
			try {
				IDebugTarget[] debugTargets = debugTarget.getLaunch().getDebugTargets();
				for (IDebugTarget current : debugTargets) {
					current.suspend();
				}
			} catch (DebugException e) {
				e.printStackTrace();
			}
		}
	});
}
 

public IStackFrame[] getStackFrames( ) throws DebugException
{
	IStackFrame[] retValue;
	if ( isSuspended( ) )
	{
		retValue = ( (ScriptDebugTarget) getDebugTarget( ) ).getStackFrames( );
	}
	else
	{
		retValue = new IStackFrame[0];
	}
	return retValue;
}
 

public void terminate() throws DebugException {
    if (running) {
        if (browser != null) {
            browser.stop();
        }
        running = false;
        DebugEvent[] eventSet = new DebugEvent[2];
        eventSet[0] = new DebugEvent(this, DebugEvent.TERMINATE);
        eventSet[1] = new DebugEvent(launch, DebugEvent.CHANGE);
        DebugPlugin.getDefault().fireDebugEventSet(eventSet);
    }
}
 

public void terminate( ) throws DebugException
{
	setTerminating( true );
	try
	{
		// Process the proces is terminated by client directly.
		if ( ( !isTerminated( ) ) && reportVM.isTerminated( ) )
		{
			terminated( );
			return;
		}
	}
	catch ( VMException e1 )
	{
		logger.warning( e1.getMessage( ) );
	}

	try
	{
		reportVM.terminate( );

	}
	catch ( VMException e )
	{
		logger.warning( e.getMessage( ) );
	}
}
 

public IStackFrame getTopStackFrame( ) throws DebugException
{
	IStackFrame[] frames = getStackFrames( );
	if ( frames.length > 0 )
	{
		return frames[0];
	}
	return null;
}
 

private void terminateLaunch( ILaunch launch ) {
  try {
    if( launch.canTerminate() ) {
      launch.terminate();
    }
  } catch( DebugException e ) {
    status.merge( e.getStatus() );
  }
}
 

private static void terminateLaunch( ILaunch launch ) {
  try {
    launch.terminate();
  } catch( DebugException debugException ) {
    StatusManager.getManager().handle( debugException.getStatus(), StatusManager.LOG );
  }
}
 

@Override
public String getText(Object element) {
  if (element instanceof IDebugTarget) {
    try {
      IDebugTarget target = (IDebugTarget) element;
      String text = target.getName();
      return target.isTerminated() ? Messages.getString("target.terminated", text) : text;
    } catch (DebugException ex) {
      logger.log(Level.FINE, "Unexpected execption", ex);
      /* FALLTHROUGH */
    }
  }
  return super.getText(element);
}
 

@Override
public boolean visit(MethodDeclaration node) {
	try {
		// TODO: improve the comparison of the method which is visited and the debug
		// frame
		inFrame = (node.getName().toString().equals(fFrame.getMethodName()));
	} catch (DebugException e) {
		e.printStackTrace();
	}
	return super.visit(node);
}
 

public String getDisplayName( )
{
	try
	{
		return getName( );
	}
	catch ( DebugException e )
	{
		return NAME;
	}
}
 

/**
 * Step into
 * 
 * @throws DebugException
 */
public void stepInto( ) throws DebugException
{
	try
	{
		thread.setStepping( true );
		reportVM.stepInto( );
	}
	catch ( VMException e )
	{
		logger.warning( e.getMessage( ) );
	}

}
 

@Test
public void testWaitUntilLaunchTerminates_normalExit()
    throws DebugException, InterruptedException {
  IProcess process = mock(IProcess.class);
  when(process.getExitValue()).thenReturn(0);

  ILaunch launch = mock(ILaunch.class);
  when(launch.isTerminated()).thenReturn(true);
  when(launch.getProcesses()).thenReturn(new IProcess[] {process, process});

  boolean normalExit = FlexMavenPackagedProjectStagingDelegate.waitUntilLaunchTerminates(
      launch, new NullProgressMonitor());
  assertTrue(normalExit);
}
 

public void terminate() {
	if (process != null && process.isAlive()) {
		process.destroy();
	}
	if (launch != null && !launch.isTerminated()) {
		try {
			launch.terminate();
		} catch (DebugException e) {
			Logger.logError("An error occured trying to terminate the port forward launch: " + localPort + ":" + remotePort, e);
		}
	}
}
 

public void suspend( ) throws DebugException
{
	try
	{
		reportVM.suspend( );
	}
	catch ( VMException e )
	{
		logger.warning( e.getMessage( ) );
	}
}
 

public String getDisplayName( )
{
	try
	{
		return getName( );
	}
	catch ( DebugException e )
	{
		return getDefaultName( );
	}
}
 

public String getDisplayName( )
{
	try
	{
		return getName( );
	}
	catch ( DebugException e )
	{
		return name;
	}
}
 

/**
 * Step return
 * 
 * @throws DebugException
 */
public void stepReturn( ) throws DebugException
{
	try
	{
		thread.setStepping( true );
		reportVM.stepOut( );
	}
	catch ( VMException e )
	{
		logger.warning( e.getMessage( ) );
	}

}
 

/**
* @return The processee's exit/return value or -1 if unknown.
*/
  public int getExitValue() {
  	if (this.process != null) {
  		try {
  			return this.process.getExitValue();
  		} catch (DebugException shouldNotHappen) {
  			shouldNotHappen.printStackTrace();
  		}
  	}
  	return 255;
  }
 

/**
 * This method terminates the current DSF-GDB session
 */
public void dispose() {
    if (fLaunch != null && fLaunch.canTerminate() && !isTerminating) {
        isTerminating = true;
        try {
            fLaunch.terminate();
        } catch (DebugException e) {
            GdbTraceCorePlugin.logError(e.getMessage(), e);
        }
        fLaunch = null;
    }
}
 

public void terminate() throws DebugException {
	fireEvent(new DebugEvent(getDebugTarget(), DebugEvent.TERMINATE));
	terminated = true;
	executionControl.terminate();
	if (engine.getExecutionContext() != null)
		engine.getExecutionContext().eAdapters().remove(updater);
}
 

/**
 * @param value
 * @return
 * @throws DebugException
 */
private String getValueText( IValue value ) throws DebugException
{

	String refTypeName = value.getReferenceTypeName( );
	String valueString = value.getValueString( );
	boolean isString = false;

	// boolean isObject = true;
	// boolean isArray = value instanceof IJavaArray;
	StringBuffer buffer = new StringBuffer( );
	// Always show type name for objects & arrays (but not Strings)
	if ( !isString && ( refTypeName.length( ) > 0 ) )
	{
		String qualTypeName = refTypeName;
		buffer.append( qualTypeName );
		buffer.append( ' ' );

	}

	// Put double quotes around Strings
	if ( valueString != null && ( isString || valueString.length( ) > 0 ) )
	{
		if ( isString )
		{
			buffer.append( '"' );
		}
		buffer.append( valueString );
		if ( isString )
		{
			buffer.append( '"' );
		}
	}

	return buffer.toString( );
}