Example #1
0
 /**
  * Notifies this listener that the given breakpoint has been added to the breakpoint manager.
  *
  * @param breakpoint the added breakpoint
  * @since 2.0
  */
 public void breakpointAdded(IBreakpoint breakpoint) {
   if (!isAvailable()) {
     return;
   }
   if (supportsBreakpoint(breakpoint)) {
     try {
       if (breakpoint.isEnabled()) {
         // only add the breakpoint to the debugger when the
         // breakpoint is enabled
         int linenumber = breakpoint.getMarker().getAttribute(IMarker.LINE_NUMBER, -1);
         // TODO: get marker language type or get language from the
         // resource
         IResource r = breakpoint.getMarker().getResource();
         String pRel = r.getProjectRelativePath().toOSString();
         String filename = pRel;
         if (linenumber > 0) {
           // only linenumbers greater than 0 are valid as
           // linenumber is 1-based
           // convert the Eclipse breakpoint to an internal
           // representation of breakpoints
           AbstractBreakPoint bp = createBreakpoint(filename, linenumber);
           if (bp != null) {
             this.getVMContainer().addBreakpoint(bp);
           }
         }
       }
     } catch (CoreException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
     }
   }
 }
  @Override
  public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection)
      throws CoreException {
    AbstractTextEditor editor = getEditor(part);

    if (editor != null) {
      IResource resource = (IResource) editor.getEditorInput().getAdapter(IResource.class);

      ITextSelection textSelection = (ITextSelection) selection;

      int lineNumber = textSelection.getStartLine() + 1;

      IBreakpoint[] breakpoints =
          DebugPlugin.getDefault()
              .getBreakpointManager()
              .getBreakpoints(DartDebugCorePlugin.DEBUG_MODEL_ID);

      for (int i = 0; i < breakpoints.length; i++) {
        IBreakpoint breakpoint = breakpoints[i];

        if (resource.equals(breakpoint.getMarker().getResource())) {
          if (((ILineBreakpoint) breakpoint).getLineNumber() == lineNumber) {
            breakpoint.delete();
            return;
          }
        }
      }

      DartBreakpoint breakpoint = new DartBreakpoint(resource, lineNumber);

      DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(breakpoint);
    }
  }
 public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection)
     throws CoreException {
   if (part instanceof IEditorPart) {
     IEditorPart editor = (IEditorPart) part;
     IResource resource = (IResource) editor.getEditorInput().getAdapter(IResource.class);
     ITextSelection textSelection = (ITextSelection) selection;
     int lineNumber = textSelection.getStartLine();
     IBreakpoint[] breakpoints =
         DebugPlugin.getDefault()
             .getBreakpointManager()
             .getBreakpoints(IDroolsDebugConstants.ID_DROOLS_DEBUG_MODEL);
     for (int i = 0; i < breakpoints.length; i++) {
       IBreakpoint breakpoint = breakpoints[i];
       if (resource.equals(breakpoint.getMarker().getResource())) {
         if (breakpoint.getMarker().getType().equals(IDroolsDebugConstants.DROOLS_MARKER_TYPE)) {
           if (((DroolsLineBreakpoint) breakpoint).getDRLLineNumber() == (lineNumber + 1)) {
             breakpoint.delete();
             return;
           }
         }
       }
     }
     // TODO: drools breakpoints can only be created in functions and consequences
     DroolsLineBreakpoint lineBreakpoint = new DroolsLineBreakpoint(resource, lineNumber + 1);
     DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(lineBreakpoint);
   }
 }
Example #4
0
  public IBreakpoint findIBreakpoint(String filename, int lineNumber) {
    IBreakpoint[] breakpoints =
        DebugPlugin.getDefault()
            .getBreakpointManager()
            .getBreakpoints(this.debugServiceFactory.getLIConstants().getDebugModel());
    for (int i = 0; i < breakpoints.length; i++) {
      IBreakpoint breakpoint = breakpoints[i];
      if (supportsBreakpoint(breakpoint)) {

        try {
          if (breakpoint.isEnabled()) {
            // only add the breakpoint to the debugger when the
            // breakpoint is enabled
            int l = breakpoint.getMarker().getAttribute(IMarker.LINE_NUMBER, -1);
            // TODO: get marker language type or get language from
            // the resource
            IResource r = breakpoint.getMarker().getResource();
            String location = r.getProjectRelativePath().toOSString();
            if (l > 0) {
              // only linenumbers greater than 0 are valid as
              // linenumber is 1-based
              if (location.equals(filename) && lineNumber == l) {
                return breakpoint;
              }
            }
          }
        } catch (CoreException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      }
    }
    return null;
  }
 protected void toggleWatchpoint(
     IResource resource,
     int lineNumber,
     String fcn,
     String var,
     boolean access,
     boolean modification)
     throws CoreException {
   // look for existing watchpoint to delete
   IBreakpoint[] breakpoints =
       DebugPlugin.getDefault()
           .getBreakpointManager()
           .getBreakpoints(DebugCorePlugin.ID_PDA_DEBUG_MODEL);
   for (int i = 0; i < breakpoints.length; i++) {
     IBreakpoint breakpoint = breakpoints[i];
     if (breakpoint instanceof PDAWatchpoint
         && resource.equals(breakpoint.getMarker().getResource())) {
       PDAWatchpoint watchpoint = (PDAWatchpoint) breakpoint;
       String otherVar = watchpoint.getVariableName();
       String otherFcn = watchpoint.getFunctionName();
       if (otherVar.equals(var) && otherFcn.equals(fcn)) {
         breakpoint.delete();
         return;
       }
     }
   }
   // create watchpoint
   PDAWatchpoint watchpoint =
       new PDAWatchpoint(resource, lineNumber + 1, fcn, var, access, modification);
   DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(watchpoint);
 }
  /* (non-Javadoc)
   * @see org.eclipse.debug.ui.actions.IToggleBreakpointsTarget#toggleLineBreakpoints(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
   */
  public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection)
      throws CoreException {
    IEditorPart editorPart = (IEditorPart) part;
    IEditorInput editorInput = editorPart.getEditorInput();
    IResource resource = null;
    if (editorInput instanceof IFileEditorInput) {
      resource = ((IFileEditorInput) editorInput).getFile();
    }
    if (resource == null) {
      Display.getCurrent().beep();
      return;
    }

    ITextSelection textSelection = (ITextSelection) selection;
    int lineNumber = textSelection.getStartLine();
    IBreakpoint[] breakpoints =
        DebugPlugin.getDefault()
            .getBreakpointManager()
            .getBreakpoints(IAntDebugConstants.ID_ANT_DEBUG_MODEL);
    for (int i = 0; i < breakpoints.length; i++) {
      IBreakpoint breakpoint = breakpoints[i];
      if (resource.equals(breakpoint.getMarker().getResource())) {
        if (((ILineBreakpoint) breakpoint).getLineNumber() == (lineNumber + 1)) {
          DebugUITools.deleteBreakpoints(
              new IBreakpoint[] {breakpoint}, part.getSite().getShell(), null);
          return;
        }
      }
    }
    // create line breakpoint (doc line numbers start at 0)
    new AntLineBreakpoint(resource, lineNumber + 1);
  }
 /* (non-Javadoc)
  * @see org.eclipse.debug.ui.actions.IToggleBreakpointsTarget#toggleLineBreakpoints(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
  */
 @Override
 public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection)
     throws CoreException {
   ITextEditor textEditor = getEditor(part);
   if (textEditor != null) {
     IResource resource = textEditor.getEditorInput().getAdapter(IResource.class);
     ITextSelection textSelection = (ITextSelection) selection;
     int lineNumber = textSelection.getStartLine();
     IBreakpoint[] breakpoints =
         DebugPlugin.getDefault()
             .getBreakpointManager()
             .getBreakpoints(DebugCorePlugin.ID_PDA_DEBUG_MODEL);
     for (int i = 0; i < breakpoints.length; i++) {
       IBreakpoint breakpoint = breakpoints[i];
       if (breakpoint instanceof ILineBreakpoint
           && resource.equals(breakpoint.getMarker().getResource())) {
         if (((ILineBreakpoint) breakpoint).getLineNumber() == (lineNumber + 1)) {
           // remove
           breakpoint.delete();
           return;
         }
       }
     }
     // create line breakpoint (doc line numbers start at 0)
     PDALineBreakpoint lineBreakpoint = new PDALineBreakpoint(resource, lineNumber + 1);
     DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(lineBreakpoint);
   }
 }
 public void enableLineBreakpoint(IFile file, int lineNumber) throws CoreException {
   try {
     IBreakpoint lineBkpt = findStratumBreakpoint(file, lineNumber);
     if (lineBkpt != null) {
       lineBkpt.setEnabled(true);
     }
   } catch (CoreException e) {
     e.printStackTrace();
   }
 }
  public void clearLineBreakpoint(IFile file, int lineNumber) throws CoreException {
    try {
      IBreakpoint lineBkpt = findStratumBreakpoint(file, lineNumber);

      if (lineBkpt != null) {
        lineBkpt.delete();
      }
    } catch (CoreException e) {
      e.printStackTrace();
    }
  }
Example #10
0
 protected void collectBrakePoint(IResource resource) throws CoreException {
   fBreakpoints = new BucketMap<IResource, IBreakpoint>(6);
   fBreakpointAttributes = new HashMap<IBreakpoint, Map<String, Object>>(6);
   final IBreakpointManager breakpointManager = DebugPlugin.getDefault().getBreakpointManager();
   IMarker[] markers =
       resource.findMarkers(IBreakpoint.LINE_BREAKPOINT_MARKER, true, IResource.DEPTH_INFINITE);
   for (IMarker marker : markers) {
     IResource markerResource = marker.getResource();
     IBreakpoint breakpoint = breakpointManager.getBreakpoint(marker);
     if (breakpoint != null) {
       fBreakpoints.add(markerResource, breakpoint);
       fBreakpointAttributes.put(breakpoint, breakpoint.getMarker().getAttributes());
     }
   }
 }
 /*
  * @see org.eclipse.debug.core.IBreakpointListener#breakpointRemoved(org.eclipse.debug.core.model.IBreakpoint, org.eclipse.core.resources.IMarkerDelta)
  */
 @Override
 public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
   Annotation a = findAnnotation(breakpoint.getMarker());
   if (a != null) {
     removeAnnotation(a, true);
   }
 }
 /*
  * (non-Javadoc)
  *
  * @see org.eclipse.jface.action.IAction#run()
  */
 public void run() {
   try {
     /*
      * Test if there are any markers at the current position.
      * if there are any, remove breakpointmarker, otherwise create a
      * new one.
      */
     List list = getMarkers();
     if (list.isEmpty()) {
       // create new markers
       IDocument document = getDocument();
       int lineNumber = getVerticalRulerInfo().getLineOfLastMouseButtonActivity();
       if (lineNumber >= document.getNumberOfLines()) {
         return;
       }
       try {
         IRegion line = document.getLineInformation(lineNumber);
         ITextSelection selection =
             new TextSelection(document, line.getOffset(), line.getLength());
         // fBreakpointAdapter.toggleLineBreakpoints(fTextEditor, selection);
         fBreakpointAdapter.toggleBreakpoints(fTextEditor, selection);
       } catch (BadLocationException e) {
         // likely document is folded so you cannot get the line information of the folded line
       }
     } else {
       // remove existing breakpoints of any type
       IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
       Iterator iterator = list.iterator();
       while (iterator.hasNext()) {
         IMarker marker = (IMarker) iterator.next();
         IBreakpoint breakpoint = manager.getBreakpoint(marker);
         if (breakpoint != null) {
           breakpoint.delete();
         }
       }
     }
   } catch (CoreException e) {
     // JDIDebugUIPlugin.errorDialog(ActionMessages.getString("ManageBreakpointRulerAction.error.adding.message1"), e); //$NON-NLS-1$
     // JDIDebugUIPlugin.errorDialog(ActionMessages.ManageBreakpointRulerAction_error_adding_message1, e);
     // This message may not make sense FIXME
     JDIDebugUIPlugin.errorDialog(
         ActionMessages.ManageMethodBreakpointActionDelegate_methodNonAvailable, e);
   }
 }
Example #13
0
 @Override
 public void run() {
   if (breakpoint != null) {
     try {
       breakpoint.delete();
     } catch (CoreException e) {
       SDBGDebugUIPlugin.logError(e);
     }
   }
 }
  /**
   * Compares two breakpoints.
   *
   * @param b1
   * @param b2
   * @return
   */
  private int doCompare(IBreakpoint b1, IBreakpoint b2) {
    String text1 = IInternalDebugCoreConstants.EMPTY_STRING;
    String text2 = IInternalDebugCoreConstants.EMPTY_STRING;

    text1 += b1.getModelIdentifier();
    text2 += b2.getModelIdentifier();

    IMarker marker1 = b1.getMarker();
    IMarker marker2 = b2.getMarker();
    try {
      if (marker1.exists() && marker2.exists()) {
        text1 += SPACE + marker1.getType();
        text2 += SPACE + marker2.getType();
      }
    } catch (CoreException e) {
      DebugUIPlugin.log(e);
    }

    int result = text1.compareTo(text2);
    if (result != 0) {
      return result;
    }

    // model and type are the same
    if (fContext != null) {
      String name1 = fContext.getModelPresentation().getText(b1);
      String name2 = fContext.getModelPresentation().getText(b2);

      boolean lineBreakpoint = false;
      try {
        lineBreakpoint = marker1.isSubtypeOf(IBreakpoint.LINE_BREAKPOINT_MARKER);
      } catch (CoreException ce) {
      }
      if (lineBreakpoint) {
        return compareLineBreakpoints(b1, b2, name1, name2);
      }

      return name1.compareTo(name2);
    }

    return result;
  }
Example #15
0
 /**
  * Notifies this listener that the given breakpoint has been removed from the breakpoint manager.
  * If the given breakpoint has been removed because it has been deleted, the associated marker
  * delta is also provided.
  *
  * @param breakpoint the removed breakpoint
  * @param delta the associated marker delta, or <code>null</code> when the breakpoint is removed
  *     from the breakpoint manager without being deleted
  * @see org.eclipse.core.resources.IMarkerDelta
  * @since 2.0
  */
 public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
   if (!isAvailable()) {
     return;
   }
   if (supportsBreakpoint(breakpoint)) {
     // convert IBreakpoint to AbstractBreakPoint Breakpoint
     int linenumber = breakpoint.getMarker().getAttribute(IMarker.LINE_NUMBER, -1);
     IResource r = breakpoint.getMarker().getResource();
     String pRel = r.getProjectRelativePath().toOSString();
     String filename = pRel;
     if (linenumber > 0) {
       // only linenumbers greater than 0 are valid as linenumber is
       // 1-based
       AbstractBreakPoint bp = createBreakpoint(filename, linenumber);
       if (bp != null) {
         this.getVMContainer().removeBreakpoint(bp);
       }
     }
   }
 }
Example #16
0
 public static List<String> addBreakpointProjectsAndModules(
     final Collection<IProject> projects, final Collection<String> interpretedModules2) {
   final IBreakpointManager bpm = DebugPlugin.getDefault().getBreakpointManager();
   final List<String> result = Lists.newArrayList(interpretedModules2);
   for (final IBreakpoint bp : bpm.getBreakpoints(ErlDebugConstants.ID_ERLANG_DEBUG_MODEL)) {
     final IMarker m = bp.getMarker();
     final IResource r = m.getResource();
     final String name = r.getName();
     if (ModuleKind.hasErlExtension(name)) {
       final IProject p = r.getProject();
       if (projects.contains(p)) {
         final String s = p.getName() + ":" + name;
         if (!result.contains(s)) {
           result.add(s);
         }
       }
     }
   }
   return result;
 }
Example #17
0
 /**
  * Returns true whether this target can install the given breakpoint. We have to make sure the
  * language ids match
  */
 public boolean supportsBreakpoint(IBreakpoint breakpoint) {
   if (breakpoint
       .getModelIdentifier()
       .equals(this.debugServiceFactory.getLIConstants().getDebugModel())) {
     // TODO: JDIDebugTarget implements this as <code>return breakpoint
     // instanceof IJavaBreakpoint;</code>
     return true;
   } else {
     return false;
   }
 }
Example #18
0
 /**
  * Notifies this listener that an attribute of the given breakpoint has changed, as described by
  * the delta.
  *
  * @param breakpoint the changed breakpoint
  * @param delta the marker delta that describes the changes with the marker associated with the
  *     given breakpoint, or <code>null</code> when the breakpoint change does not generate a
  *     marker delta
  * @see org.eclipse.core.resources.IMarkerDelta
  */
 public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
   if (supportsBreakpoint(breakpoint)) {
     try {
       if (breakpoint.isEnabled()) {
         breakpointAdded(breakpoint);
       } else {
         breakpointRemoved(breakpoint, null);
       }
     } catch (CoreException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
     }
   }
 }
 /*
  * @see org.eclipse.debug.core.IBreakpointListener#breakpointChanged(org.eclipse.debug.core.model.IBreakpoint, org.eclipse.core.resources.IMarkerDelta)
  */
 @Override
 public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
   Annotation a = findAnnotation(breakpoint.getMarker());
   if (a != null) {
     if (a instanceof SimpleMarkerAnnotation) {
       ((SimpleMarkerAnnotation) a).update();
     }
     synchronized (getLockObject()) {
       getAnnotationModelEvent().annotationChanged(a);
     }
     fireModelChanged();
   } else {
     addBreakpointAnnotation(breakpoint, true);
   }
 }
Example #20
0
 private boolean hidePlantingAnnotation(IAnnotationModel model, IBreakpoint bp, Position p) {
   // Check if a breakpoint annotation does not need to be shown
   // since it has same position as the breakpoint marker.
   @SuppressWarnings("rawtypes")
   Iterator i = model.getAnnotationIterator();
   while (i.hasNext()) {
     Annotation a = (Annotation) i.next();
     if (a instanceof MarkerAnnotation) {
       Position q = model.getPosition(a);
       if (q != null && p.getOffset() == q.getOffset()) {
         if (bp.getMarker().equals(((MarkerAnnotation) a).getMarker())) return true;
       }
     }
   }
   return false;
 }
 private void addBreakpointAnnotation(IBreakpoint breakpoint, boolean fireEvent) {
   if (fDocument == null) {
     return;
   }
   final IMarker marker = breakpoint.getMarker();
   if (marker == null) {
     return;
   }
   try {
     Position position = createPositionFromBreakpoint(breakpoint);
     if (position != null) {
       addAnnotation(new MarkerAnnotation(marker), position, fireEvent);
     }
   } catch (CoreException exc) {
     // ignore problems accessing attributes
   } catch (BadLocationException exc) {
     // ignore wrong positions
   }
 }
  private Position createPositionFromBreakpoint(IBreakpoint breakpoint) throws CoreException {
    IBreakpointLocationProvider locationProvider =
        breakpoint.getAdapter(IBreakpointLocationProvider.class);

    /* if there is a location provider, than use the provider to retrieve the location */
    if (locationProvider != null) {

      /* if there is source info, than create a source line position */
      String sourceFile = locationProvider.getSourceFile(breakpoint, fDebugContext);
      if (sourceFile != null) {
        int lineNumber = locationProvider.getLineNumber(breakpoint, fDebugContext) - 1;
        return createPositionFromSourceLine(sourceFile, lineNumber);

      } else {
        /* if there is label info, than create a label position */
        IAddress labelAddress = locationProvider.getLabelAddress(breakpoint, fDebugContext);
        if (labelAddress != null) {
          return createPositionFromLabel(labelAddress.getValue());

          /* Otherwise, create an address position */
        } else {
          // See bug 300053 comment 5:
          // Since there can only be one annotation per marker and in order to support multiple
          // annotations per breakpoint, we need a specialized annotation type.
          //
          // So for now, we only create an annotation for the first valid address. We can add
          // support for multiple annotations per breakpoint when it's needed.
          IAddress[] addresses = locationProvider.getAddresses(breakpoint, fDebugContext);
          for (int i = 0; addresses != null && i < addresses.length; ++i) {
            BigInteger address = addresses[i].getValue();
            Position position = createPositionFromAddress(address);
            if (position != null) return position;
          }
        }
      }

      /* otherwise, use legacy ICBreakpoint location info */
    } else {
      if (breakpoint instanceof ICAddressBreakpoint) {
        ICAddressBreakpoint addressBreakpoint = (ICAddressBreakpoint) breakpoint;
        return createPositionFromAddress(decodeAddress(addressBreakpoint.getAddress()));
      } else if (breakpoint instanceof ILineBreakpoint) {
        ILineBreakpoint lineBreakpoint = (ILineBreakpoint) breakpoint;
        Position position = null;
        final int lineNumber = lineBreakpoint.getLineNumber() - 1;
        final IMarker marker = breakpoint.getMarker();
        if (marker.getResource().getType() == IResource.FILE) {
          position = createPositionFromSourceLine((IFile) marker.getResource(), lineNumber);
          if (position != null) {
            return position;
          }
        }
        String fileName = marker.getAttribute(ICLineBreakpoint.SOURCE_HANDLE, null);
        position = createPositionFromSourceLine(fileName, lineNumber);
        if (position == null && breakpoint instanceof ICLineBreakpoint) {
          ICLineBreakpoint cBreakpoint = (ICLineBreakpoint) breakpoint;
          if (breakpoint instanceof ICFunctionBreakpoint) {
            position = createPositionFromLabel(cBreakpoint.getFunction());
          } else {
            position = createPositionFromAddress(decodeAddress(cBreakpoint.getAddress()));
          }
        }
        return position;
      }
    }
    return null;
  }
  @Override
  public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection)
      throws CoreException {
    TextSelection textSelection = (TextSelection) selection;
    int lineNumber = textSelection.getStartLine();
    IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints();

    if (part instanceof IEditorPart) {
      IEditorPart editor = (IEditorPart) part;
      IResource resource = (IResource) editor.getEditorInput().getAdapter(IResource.class);

      if (resource != null) {
        for (int i = 0; i < breakpoints.length; i++) {
          IBreakpoint breakpoint = breakpoints[i];
          if (resource.equals(breakpoint.getMarker().getResource())) {
            if (((ILineBreakpoint) breakpoint).getLineNumber() == (lineNumber + 1)) {
              breakpoint.delete();
              return;
            }
          }
        }
        String path = ClojureCore.getAsRootClasspathRelativePath((IFile) resource).substring(1);
        JDIDebugModel.createStratumBreakpoint(
            resource,
            "Clojure",
            resource.getName(),
            path,
            null,
            lineNumber + 1,
            -1,
            -1,
            0,
            true,
            null);
      } else {
        // Do it "the hard way" by using the WorkspaceRoot as the host for our breakpoint
        // ... quick analysis seems to indicate it's done this way by the JDT "itself" !
        IStorageEditorInput input = (IStorageEditorInput) editor.getEditorInput();
        IStorage storage = input.getStorage();

        for (int i = 0; i < breakpoints.length; i++) {
          IBreakpoint breakpoint = breakpoints[i];
          if (breakpoint instanceof IJavaStratumLineBreakpoint) {
            IJavaStratumLineBreakpoint stratumBreakpoint = (IJavaStratumLineBreakpoint) breakpoint;
            if (storage
                .getFullPath()
                .toPortableString()
                .equals(stratumBreakpoint.getSourcePath())) {
              if (((ILineBreakpoint) breakpoint).getLineNumber() == (lineNumber + 1)) {
                breakpoint.delete();
                return;
              }
            }
          }
        }
        Map attributes = new HashMap();
        StorageMarkerAnnotationModel.addAttribute(attributes, storage);
        System.out.println("not editor part resource");
        JDIDebugModel.createStratumBreakpoint(
            ResourcesPlugin.getWorkspace().getRoot(),
            "Clojure",
            storage.getName(),
            storage.getFullPath().toPortableString(),
            null,
            lineNumber + 1,
            -1,
            -1,
            0,
            true,
            attributes);
      }
    }
  }