Merge branch 'master' of https://github.com/JesusFreke/intellij-community
authorEgor.Ushakov <egor.ushakov@jetbrains.com>
Mon, 9 Feb 2015 11:51:43 +0000 (14:51 +0300)
committerEgor.Ushakov <egor.ushakov@jetbrains.com>
Mon, 9 Feb 2015 11:51:43 +0000 (14:51 +0300)
1  2 
java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java

index 771fd27a574451a6b129bf2a9bdfb00f6bb97bca,2a4d3528b4ac99cbcf9c6a7b29c4dc4d118085b0..29a2c3414695d3e1522f71ed42f55108088ad08d
@@@ -58,7 -58,6 +58,7 @@@ import com.intellij.openapi.util.Dispos
  import com.intellij.openapi.util.Pair;
  import com.intellij.openapi.util.Ref;
  import com.intellij.openapi.util.UserDataHolderBase;
 +import com.intellij.openapi.util.text.StringUtil;
  import com.intellij.openapi.wm.ToolWindowId;
  import com.intellij.openapi.wm.impl.status.StatusBarUtil;
  import com.intellij.psi.PsiDocumentManager;
@@@ -369,10 -368,12 +369,12 @@@ public abstract class DebugProcessImpl 
     *
     * @param suspendContext
     * @param stepThread
+    * @param size the step size. One of {@link StepRequest#STEP_LINE} or {@link StepRequest#STEP_MIN}
     * @param depth
     * @param hint may be null
     */
-   protected void doStep(final SuspendContextImpl suspendContext, final ThreadReferenceProxyImpl stepThread, int depth, RequestHint hint) {
+   protected void doStep(final SuspendContextImpl suspendContext, final ThreadReferenceProxyImpl stepThread, int size, int depth,
+                         RequestHint hint) {
      if (stepThread == null) {
        return;
      }
        }
        deleteStepRequests(stepThreadReference);
        EventRequestManager requestManager = getVirtualMachineProxy().eventRequestManager();
-       StepRequest stepRequest = requestManager.createStepRequest(stepThreadReference, StepRequest.STEP_LINE, depth);
+       StepRequest stepRequest = requestManager.createStepRequest(stepThreadReference, size, depth);
        if (!(hint != null && hint.isIgnoreFilters()) /*&& depth == StepRequest.STEP_INTO*/) {
          final List<ClassFilter> activeFilters = new ArrayList<ClassFilter>();
          DebuggerSettings settings = DebuggerSettings.getInstance();
        }
      }
      catch (IOException e) {
 -      throw new ExecutionException(processError(e), e);
 +      throw new ExecutionException(processIOException(e, DebuggerBundle.getAddressDisplayName(myConnection)), e);
      }
      catch (IllegalConnectorArgumentsException e) {
        throw new ExecutionException(processError(e), e);
      else if (e instanceof VMDisconnectedException) {
        message = DebuggerBundle.message("error.vm.disconnected");
      }
 -    else if (e instanceof UnknownHostException) {
 -      message = DebuggerBundle.message("error.unknown.host") + ":\n" + e.getLocalizedMessage();
 -    }
      else if (e instanceof IOException) {
 -      IOException e1 = (IOException)e;
 -      final StringBuilder buf = StringBuilderSpinAllocator.alloc();
 -      try {
 -        buf.append(DebuggerBundle.message("error.cannot.open.debugger.port")).append(" : ");
 -        buf.append(e1.getClass().getName()).append(" ");
 -        final String localizedMessage = e1.getLocalizedMessage();
 -        if (localizedMessage != null && !localizedMessage.isEmpty()) {
 -          buf.append('"');
 -          buf.append(localizedMessage);
 -          buf.append('"');
 -        }
 -        if (LOG.isDebugEnabled()) {
 -          LOG.debug(e1);
 -        }
 -        message = buf.toString();
 -      }
 -      finally {
 -        StringBuilderSpinAllocator.dispose(buf);
 -      }
 +      message = processIOException((IOException)e, null);
      }
      else if (e instanceof ExecutionException) {
        message = e.getLocalizedMessage();
      return message;
    }
  
 +  @NotNull
 +  public static String processIOException(@NotNull IOException e, @Nullable String address) {
 +    if (e instanceof UnknownHostException) {
 +      return DebuggerBundle.message("error.unknown.host") + (address != null ? " (" + address + ")" : "") + ":\n" + e.getLocalizedMessage();
 +    }
 +
 +    String message;
 +    final StringBuilder buf = StringBuilderSpinAllocator.alloc();
 +    try {
 +      buf.append(DebuggerBundle.message("error.cannot.open.debugger.port"));
 +      if (address != null) {
 +        buf.append(" (").append(address).append(")");
 +      }
 +      buf.append(": ");
 +      buf.append(e.getClass().getName()).append(" ");
 +      final String localizedMessage = e.getLocalizedMessage();
 +      if (!StringUtil.isEmpty(localizedMessage)) {
 +        buf.append('"');
 +        buf.append(localizedMessage);
 +        buf.append('"');
 +      }
 +      if (LOG.isDebugEnabled()) {
 +        LOG.debug(e);
 +      }
 +      message = buf.toString();
 +    }
 +    finally {
 +      StringBuilderSpinAllocator.dispose(buf);
 +    }
 +    return message;
 +  }
 +
    public void dispose() {
      NodeRendererSettings.getInstance().removeListener(mySettingsListener);
      Disposer.dispose(myDisposable);
    }
  
    private class StepOutCommand extends ResumeCommand {
-     public StepOutCommand(SuspendContextImpl suspendContext) {
+     private final int myStepSize;
+     public StepOutCommand(SuspendContextImpl suspendContext, int stepSize) {
        super(suspendContext);
+       myStepSize = stepSize;
      }
  
      @Override
        if (rvWatcher != null) {
          rvWatcher.enable(thread.getThreadReference());
        }
-       doStep(suspendContext, thread, StepRequest.STEP_OUT, hint);
+       doStep(suspendContext, thread, myStepSize, StepRequest.STEP_OUT, hint);
        super.contextAction();
      }
    }
      private final MethodFilter mySmartStepFilter;
      @Nullable
      private final StepIntoBreakpoint myBreakpoint;
+     private final int myStepSize;
  
-     public StepIntoCommand(SuspendContextImpl suspendContext, boolean ignoreFilters, @Nullable final MethodFilter methodFilter) {
+     public StepIntoCommand(SuspendContextImpl suspendContext, boolean ignoreFilters, @Nullable final MethodFilter methodFilter,
+                            int stepSize) {
        super(suspendContext);
        myForcedIgnoreFilters = ignoreFilters || methodFilter != null;
        mySmartStepFilter = methodFilter;
        myBreakpoint = methodFilter instanceof BreakpointStepMethodFilter ?
          DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().addStepIntoBreakpoint(((BreakpointStepMethodFilter)methodFilter)) :
          null;
+       myStepSize = stepSize;
      }
  
      @Override
          myBreakpoint.createRequest(suspendContext.getDebugProcess());
          myRunToCursorBreakpoint = myBreakpoint;
        }
-       doStep(suspendContext, stepThread, StepRequest.STEP_INTO, hint);
+       doStep(suspendContext, stepThread, myStepSize, StepRequest.STEP_INTO, hint);
        super.contextAction();
      }
    }
  
    private class StepOverCommand extends ResumeCommand {
      private final boolean myIsIgnoreBreakpoints;
+     private final int myStepSize;
  
-     public StepOverCommand(SuspendContextImpl suspendContext, boolean ignoreBreakpoints) {
+     public StepOverCommand(SuspendContextImpl suspendContext, boolean ignoreBreakpoints, int stepSize) {
        super(suspendContext);
        myIsIgnoreBreakpoints = ignoreBreakpoints;
+       myStepSize = stepSize;
      }
  
      @Override
          rvWatcher.enable(stepThread.getThreadReference());
        }
  
-       doStep(suspendContext, stepThread, StepRequest.STEP_OVER, hint);
+       doStep(suspendContext, stepThread, myStepSize, StepRequest.STEP_OVER, hint);
  
        if (myIsIgnoreBreakpoints) {
          DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().disableBreakpoints(DebugProcessImpl.this);
    }
  
    public ResumeCommand createStepOverCommand(SuspendContextImpl suspendContext, boolean ignoreBreakpoints) {
-     return new StepOverCommand(suspendContext, ignoreBreakpoints);
+     return createStepOverCommand(suspendContext, ignoreBreakpoints, StepRequest.STEP_LINE);
+   }
+   public ResumeCommand createStepOverCommand(SuspendContextImpl suspendContext, boolean ignoreBreakpoints, int stepSize) {
+     return new StepOverCommand(suspendContext, ignoreBreakpoints, stepSize);
    }
  
    public ResumeCommand createStepOutCommand(SuspendContextImpl suspendContext) {
-     return new StepOutCommand(suspendContext);
+     return createStepOutCommand(suspendContext, StepRequest.STEP_LINE);
+   }
+   public ResumeCommand createStepOutCommand(SuspendContextImpl suspendContext, int stepSize) {
+     return new StepOutCommand(suspendContext, stepSize);
    }
  
    public ResumeCommand createStepIntoCommand(SuspendContextImpl suspendContext, boolean ignoreFilters, final MethodFilter smartStepFilter) {
-     return new StepIntoCommand(suspendContext, ignoreFilters, smartStepFilter);
+     return createStepIntoCommand(suspendContext, ignoreFilters, smartStepFilter, StepRequest.STEP_LINE);
+   }
+   public ResumeCommand createStepIntoCommand(SuspendContextImpl suspendContext, boolean ignoreFilters, final MethodFilter smartStepFilter,
+                                              int stepSize) {
+     return new StepIntoCommand(suspendContext, ignoreFilters, smartStepFilter, stepSize);
    }
  
    public ResumeCommand createRunToCursorCommand(SuspendContextImpl suspendContext, Document document, int lineIndex,