diff --git a/plugin.xml b/plugin.xml index 0f7803f..b70ff84 100644 --- a/plugin.xml +++ b/plugin.xml @@ -52,8 +52,8 @@ @@ -63,8 +63,30 @@ + + + + + + + + + + + + @@ -77,41 +99,63 @@ point="org.eclipse.ui.ide.markerImageProviders"> + id="BottomDeltaMarker" + markertype="org.ntlab.traceDebugger.bottomDeltaMarker"> + id="CoordinatorDeltaMarker" + markertype="org.ntlab.traceDebugger.coordinatorDeltaMarker"> + + + + + + + + + + + + diff --git a/src/org/ntlab/traceDebugger/CallStackLabelProvider.java b/src/org/ntlab/traceDebugger/CallStackLabelProvider.java index aa467e8..119b894 100644 --- a/src/org/ntlab/traceDebugger/CallStackLabelProvider.java +++ b/src/org/ntlab/traceDebugger/CallStackLabelProvider.java @@ -1,13 +1,17 @@ package org.ntlab.traceDebugger; +import org.eclipse.jface.viewers.IColorProvider; import org.eclipse.jface.viewers.LabelProvider; import org.eclipse.jface.viewers.TreeNode; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Display; import org.eclipse.ui.ISharedImages; import org.eclipse.ui.PlatformUI; import org.ntlab.traceAnalysisPlatform.tracer.trace.ThreadInstance; -public class CallStackLabelProvider extends LabelProvider { +public class CallStackLabelProvider extends LabelProvider implements IColorProvider { @Override public String getText(Object element) { @@ -36,4 +40,26 @@ } return null; } + + @Override + public Color getForeground(Object element) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Color getBackground(Object element) { + // TODO Auto-generated method stub + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof CallStackModel) { + CallStackModel callStackModel = (CallStackModel)value; + if (callStackModel.isHighlighting()) { +// return Display.getDefault().getSystemColor(SWT.COLOR_CYAN); + return Display.getDefault().getSystemColor(SWT.COLOR_CYAN); + } + } + } + return null; + } } diff --git a/src/org/ntlab/traceDebugger/CallStackModel.java b/src/org/ntlab/traceDebugger/CallStackModel.java index dd056a2..147e272 100644 --- a/src/org/ntlab/traceDebugger/CallStackModel.java +++ b/src/org/ntlab/traceDebugger/CallStackModel.java @@ -6,6 +6,7 @@ public class CallStackModel { private TracePoint tracePoint; + private boolean isHighlighting; public CallStackModel(TracePoint tracePoint) { this.tracePoint = tracePoint; @@ -47,5 +48,13 @@ sb.append("." + methodName + args); signature = sb.toString(); return signature; + } + + public boolean isHighlighting() { + return isHighlighting; + } + + public void setHighlighting(boolean isHighlighting) { + this.isHighlighting = isHighlighting; } } diff --git a/src/org/ntlab/traceDebugger/CallStackModels.java b/src/org/ntlab/traceDebugger/CallStackModels.java index 60a0460..0a77207 100644 --- a/src/org/ntlab/traceDebugger/CallStackModels.java +++ b/src/org/ntlab/traceDebugger/CallStackModels.java @@ -20,6 +20,10 @@ public List getDebuggingThreadCallStacks() { return debuggingThreadCallStacks; } + + public Map> getAllCallStacks() { + return allCallStacks; + } public TreeNode[] getAllCallStacksTree() { if (allCallStacks.isEmpty()) return new TreeNode[1]; diff --git a/src/org/ntlab/traceDebugger/CallStackView.java b/src/org/ntlab/traceDebugger/CallStackView.java index a55bd45..f2c112f 100644 --- a/src/org/ntlab/traceDebugger/CallStackView.java +++ b/src/org/ntlab/traceDebugger/CallStackView.java @@ -1,5 +1,8 @@ package org.ntlab.traceDebugger; +import java.util.List; +import java.util.Map; + import org.eclipse.jface.action.Action; import org.eclipse.jface.action.IAction; import org.eclipse.jface.action.IMenuManager; @@ -113,6 +116,10 @@ refresh(); } + public Map> getCallStackModels() { + return callStackModels.getAllCallStacks(); + } + private IViewPart getOtherView(String viewId) { IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); try { diff --git a/src/org/ntlab/traceDebugger/DebuggingController.java b/src/org/ntlab/traceDebugger/DebuggingController.java index 3fbc334..1005eb8 100644 --- a/src/org/ntlab/traceDebugger/DebuggingController.java +++ b/src/org/ntlab/traceDebugger/DebuggingController.java @@ -1,6 +1,5 @@ package org.ntlab.traceDebugger; -import org.eclipse.debug.core.model.IBreakpoint; import org.eclipse.jface.dialogs.InputDialog; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.swt.SWT; @@ -13,9 +12,7 @@ import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; -import org.ntlab.traceDebugger.analyzerProvider.AbstractAnalyzer; import org.ntlab.traceDebugger.analyzerProvider.DeltaExtractionAnalyzer; -import org.ntlab.traceDebugger.analyzerProvider.ReferencePoint; public class DebuggingController { private static final DebuggingController theInstance = new DebuggingController(); @@ -268,7 +265,7 @@ callStackView.updateByTracePoint(debuggingTp); callStackView.refresh(); ((VariableView)getOtherView(VariableView.ID)).updateVariablesByTracePoint(debuggingTp, isReturned); - ((BreakPointView)getOtherView(BreakPointView.ID)).update(traceBreakPoints); +// ((BreakPointView)getOtherView(BreakPointView.ID)).update(traceBreakPoints); } private IViewPart getOtherView(String viewId) { diff --git a/src/org/ntlab/traceDebugger/DeltaMarkerLabelProvider.java b/src/org/ntlab/traceDebugger/DeltaMarkerLabelProvider.java new file mode 100644 index 0000000..9d258a8 --- /dev/null +++ b/src/org/ntlab/traceDebugger/DeltaMarkerLabelProvider.java @@ -0,0 +1,109 @@ +package org.ntlab.traceDebugger; + +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jface.viewers.ITableColorProvider; +import org.eclipse.jface.viewers.ITableLabelProvider; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.jface.viewers.TreeNode; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.PlatformUI; +import org.ntlab.traceDebugger.analyzerProvider.Alias; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; + +public class DeltaMarkerLabelProvider extends LabelProvider implements ITableLabelProvider, ITableColorProvider { + + @Override + public String getColumnText(Object element, int columnIndex) { + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof String) return (columnIndex == 0) ? (String)value : null; + if (value instanceof IMarker) { + IMarker marker = (IMarker)value; + try { + switch (columnIndex) { + case 0: + return "" + marker.getAttribute(IMarker.MESSAGE); + case 1: + Object objectId = marker.getAttribute("objectId"); + return (objectId != null) ? "" + objectId : null; + case 2: + Object objectType = marker.getAttribute("objectType"); + return (objectType != null) ? "" + objectType : null; + case 3: + Object aliasType = marker.getAttribute("aliasType"); + return (aliasType != null) ? ((Alias.AliasType)aliasType).toString() : null; + case 4: + return marker.getResource().toString(); + case 5: + return "line " + marker.getAttribute(IMarker.LINE_NUMBER); + case 6: + String markerType = marker.getType(); + return markerType.substring(markerType.lastIndexOf(".") + 1); + } + } catch(CoreException e) { + e.printStackTrace(); + } + } + } + return "�e�X�g�p�e�L�X�g"; + } + + @Override + public Image getColumnImage(Object element, int columnIndex) { + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof String && columnIndex == 0) { + return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); + } + } + return null; + } + + @Override + public Color getForeground(Object element, int columnIndex) { + return null; + } + + @Override + public Color getBackground(Object element, int columnIndex) { + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof String) { + String str = (String)value; + if (str.contains("Bottom")) { + return new Color(Display.getDefault(), 255, 128, 128); + } else if (str.contains("Coordinator")) { + return Display.getDefault().getSystemColor(SWT.COLOR_GREEN); + } else if (str.contains("Src")) { + return new Color(Display.getDefault(), 255, 128, 0); + } else if (str.contains("Dst")) { + return Display.getDefault().getSystemColor(SWT.COLOR_CYAN); + } + return null; + } + if (value instanceof IMarker) { + IMarker marker = (IMarker)value; + try { + String markerType = marker.getType(); + if (markerType.equals(DeltaMarkerManager.BOTTOM_DELTA_MARKER)) { + return new Color(Display.getDefault(), 255, 128, 128); + } else if (markerType.equals(DeltaMarkerManager.COORDINATOR_DELTA_MARKER)) { + return Display.getDefault().getSystemColor(SWT.COLOR_GREEN); + } else if (markerType.equals(DeltaMarkerManager.SRC_SIDE_DELTA_MARKER)) { + return new Color(Display.getDefault(), 255, 128, 0); + } else if (markerType.equals(DeltaMarkerManager.DST_SIDE_DELTA_MARKER)) { + return Display.getDefault().getSystemColor(SWT.COLOR_CYAN); + } + } catch (CoreException e) { + e.printStackTrace(); + } + } + } + return null; + } +} diff --git a/src/org/ntlab/traceDebugger/DeltaMarkerView.java b/src/org/ntlab/traceDebugger/DeltaMarkerView.java index 97a3bee..1d09865 100644 --- a/src/org/ntlab/traceDebugger/DeltaMarkerView.java +++ b/src/org/ntlab/traceDebugger/DeltaMarkerView.java @@ -1,20 +1,203 @@ package org.ntlab.traceDebugger; -import org.eclipse.ui.IMemento; -import org.eclipse.ui.IViewSite; +import java.util.List; +import java.util.Map; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.IToolBarManager; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.SelectionChangedEvent; +import org.eclipse.jface.viewers.TreeNode; +import org.eclipse.jface.viewers.TreeNodeContentProvider; +import org.eclipse.jface.viewers.TreeViewer; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.swt.widgets.Tree; +import org.eclipse.swt.widgets.TreeColumn; +import org.eclipse.ui.IViewPart; +import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.PartInitException; -import org.eclipse.ui.views.markers.MarkerSupportView; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.ide.IDE; +import org.eclipse.ui.part.ViewPart; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; +import org.ntlab.traceDebugger.analyzerProvider.Alias; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; -public class DeltaMarkerView extends MarkerSupportView { +//public class DeltaMarkerView extends MarkerSupportView { +// private DeltaMarkerManager deltaMarkerManager; +// public static String ID = "org.ntlab.traceDebugger.deltaMarkerView"; +// +// public DeltaMarkerView() { +// super("org.ntlab.traceDebugger.markerContentGenerator"); +// } +// +// @Override +// public void init(IViewSite site, IMemento m) throws PartInitException { +// // note: ���̃��\�b�h���I�[�o�[���C�h����IMemento��null�ɂ��Ă����Ȃ��ƃR���X�g���N�^�Őݒ肵��Generator����������� +// super.init(site, null); +// } +// +// public DeltaMarkerManager getDeltaMarkerManager() { +// return deltaMarkerManager; +// } +//} + +public class DeltaMarkerView extends ViewPart { + private TreeViewer viewer; + private Shell shell; + private TracePoint bottomPoint; + private TracePoint coordinatorPoint; + private DeltaMarkerManager deltaMarkerManager = new DeltaMarkerManager(); + private String subId; public static String ID = "org.ntlab.traceDebugger.deltaMarkerView"; - - public DeltaMarkerView() { - super("org.ntlab.traceDebugger.markerContentGenerator"); + + @Override + public void createPartControl(Composite parent) { + // TODO Auto-generated method stub + System.out.println("DeltaMarkerView#createPartControl(Composite)���Ă΂ꂽ��!"); + shell = parent.getShell(); + viewer = new TreeViewer(parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION); + Tree tree = viewer.getTree(); + tree.setHeaderVisible(true); + tree.setLinesVisible(true); + + // �e�[�u���̃J�������쐬 + String[] tableColumnTexts = {"Description", "Object ID", "Object Type", "Alias Type", "Resource", "Location", "Marker"}; + int[] tableColumnWidth = {140, 100, 100, 150, 100, 60, 100}; + TreeColumn[] tableColumns = new TreeColumn[tableColumnTexts.length]; + for (int i = 0; i < tableColumns.length; i++) { + tableColumns[i] = new TreeColumn(tree, SWT.NULL); + tableColumns[i].setText(tableColumnTexts[i]); + tableColumns[i].setWidth(tableColumnWidth[i]); + } + viewer.setContentProvider(new TreeNodeContentProvider()); + viewer.setLabelProvider(new DeltaMarkerLabelProvider()); + viewer.addSelectionChangedListener(new ISelectionChangedListener() { + @Override + public void selectionChanged(SelectionChangedEvent event) { + IStructuredSelection sel = (IStructuredSelection)event.getSelection(); + Object element = sel.getFirstElement(); + if (!(element instanceof TreeNode)) return; + Object value = ((TreeNode)element).getValue(); + if (!(value instanceof IMarker)) return; + IMarker marker = (IMarker)value; + try { + DebuggingController controller = DebuggingController.getInstance(); + controller.jumpToTheTracePoint(coordinatorPoint); + IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); + IDE.openEditor(page, marker); + highlightInCallStacks(marker); + VariableView variableView = (VariableView)getOtherView(VariableView.ID); + variableView.expandParticularNodes(deltaMarkerManager.getMarkers()); + } catch (CoreException e) { + e.printStackTrace(); + } + } + }); + viewer.refresh(); + + createActions(); + createToolBar(); + createMenuBar(); + createPopupMenu(); } + private void createActions() { + // TODO Auto-generated method stub + } + + private void createToolBar() { + IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); + } + + private void createMenuBar() { + IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); + } + + private void createPopupMenu() { + // TODO Auto-generated method stub + } + @Override - public void init(IViewSite site, IMemento m) throws PartInitException { - // note: ���̃��\�b�h���I�[�o�[���C�h����IMemento��null�ɂ��Ă����Ȃ��ƃR���X�g���N�^�Őݒ肵��Generator����������� - super.init(site, null); + public void setFocus() { + // TODO Auto-generated method stub + viewer.getControl().setFocus(); + } + + public void update() { + viewer.setInput(deltaMarkerManager.getMarkerTreeNodes()); + viewer.expandAll(); + viewer.refresh(); + } + + public DeltaMarkerManager getDeltaMarkerManager() { + return deltaMarkerManager; + } + + public String getSubId() { + return subId; + } + + public TracePoint getBottomPoint() { + return bottomPoint; + } + + public TracePoint getCoordinatorPoint() { + return coordinatorPoint; + } + + public void setSubId(String subId) { + this.subId = subId; + } + + public void setBottomPoint(TracePoint bottomPoint) { + this.bottomPoint = bottomPoint; + } + + public void setCoordinatorPoint(TracePoint coordinatorPoint) { + this.coordinatorPoint = coordinatorPoint; + } + + private void highlightInCallStacks(IMarker marker) { + CallStackView callStackView = (CallStackView)getOtherView(CallStackView.ID); + callStackView.updateByTracePoint(bottomPoint); + try { + Object obj = marker.getAttribute("data"); + String signature1 = ""; + if (obj instanceof Alias) { + signature1 = ((Alias)obj).getMethodSignature(); + } else if (obj instanceof MethodExecution) { + signature1 = ((MethodExecution)obj).getCallerSideSignature(); + } + Map> threadIdTocallStackModels = callStackView.getCallStackModels(); + for (List callStackModels : threadIdTocallStackModels.values()) { + for (CallStackModel callStackModel : callStackModels) { + String signature2 = callStackModel.getMethodExecution().getCallerSideSignature(); + callStackModel.setHighlighting(signature1.equals(signature2)); + } + } + callStackView.refresh(); + } catch (CoreException e) { + e.printStackTrace(); + } + } + + public void dispose() { + deltaMarkerManager.clearAllMarkers(); + super.dispose(); + } + + private IViewPart getOtherView(String viewId) { + IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); + try { + return workbenchPage.showView(viewId); + } catch (PartInitException e) { + throw new RuntimeException(e); + } } } diff --git a/src/org/ntlab/traceDebugger/VariableView.java b/src/org/ntlab/traceDebugger/VariableView.java index ac30a38..35a36a0 100644 --- a/src/org/ntlab/traceDebugger/VariableView.java +++ b/src/org/ntlab/traceDebugger/VariableView.java @@ -5,6 +5,8 @@ import java.util.Map; import java.util.Set; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.runtime.CoreException; import org.eclipse.jface.action.Action; import org.eclipse.jface.action.IAction; import org.eclipse.jface.action.IMenuListener; @@ -37,6 +39,7 @@ import org.eclipse.ui.part.ViewPart; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; import org.ntlab.traceDebugger.analyzerProvider.AbstractAnalyzer; +import org.ntlab.traceDebugger.analyzerProvider.Alias; import org.ntlab.traceDebugger.analyzerProvider.DeltaExtractionAnalyzer; import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; @@ -146,21 +149,22 @@ public void run() { AbstractAnalyzer analyzer = TraceDebuggerPlugin.getAnalyzer(); if (analyzer instanceof DeltaExtractionAnalyzer) { - DeltaExtractionAnalyzer deltaAnalyzer = (DeltaExtractionAnalyzer)analyzer; - deltaAnalyzer.extractDelta(selectedVariable); - TracePoint coordinatorPoint = deltaAnalyzer.getCoordinatorPoint(); - DebuggingController controller = DebuggingController.getInstance(); - controller.jumpToTheTracePoint(coordinatorPoint); - + DeltaExtractionAnalyzer deltaAnalyzer = (DeltaExtractionAnalyzer)analyzer; IWorkbench workbench = PlatformUI.getWorkbench(); IWorkbenchPage workbenchPage = workbench.getActiveWorkbenchWindow().getActivePage(); try { // note: ����r���[�𕡐��J���e�X�g - workbenchPage.showView("org.eclipse.ui.views.AllMarkersView", "tmp" + Math.random(), IWorkbenchPage.VIEW_ACTIVATE); + String newDeltaMarkerViewSubId = deltaAnalyzer.getNextDeltaMarkerSubId(); + DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)workbenchPage.showView(DeltaMarkerView.ID, newDeltaMarkerViewSubId, IWorkbenchPage.VIEW_ACTIVATE); + deltaAnalyzer.extractDelta(selectedVariable, newDeltaMarkerView, newDeltaMarkerViewSubId); + TracePoint coordinatorPoint = newDeltaMarkerView.getCoordinatorPoint(); + DebuggingController controller = DebuggingController.getInstance(); + controller.jumpToTheTracePoint(coordinatorPoint); + DeltaMarkerManager deltaMarkerManager = newDeltaMarkerView.getDeltaMarkerManager(); + expandParticularNodes(deltaMarkerManager.getMarkers()); } catch (PartInitException e) { e.printStackTrace(); } - expandParticularNodes(); } } }; @@ -168,11 +172,27 @@ deltaAction.setToolTipText("Extract Delta"); } - private void expandParticularNodes() { - Map> markerIdToObjectIdSet = DeltaMarkerManager.getInstance().getMarkerIdToObjectIdSet(); - Set srcSideIdSet = new HashSet<>(markerIdToObjectIdSet.get(DeltaMarkerManager.DELTA_MARKER_ID)); - Set dstSideIdSet = new HashSet<>(markerIdToObjectIdSet.get(DeltaMarkerManager.DELTA_MARKER_ID_2)); -// Set idSet = new HashSet<>(DeltaMarkerManager.getInstance().getIdSet()); + public void expandParticularNodes(Map> markers) { + Set srcSideIdSet = new HashSet<>(); + Set dstSideIdSet = new HashSet<>(); + for (Map.Entry> entry : markers.entrySet()) { + String markerId = entry.getKey(); + List markerList = entry.getValue(); + for (IMarker marker : markerList) { + try { + Object obj = marker.getAttribute("data"); + if (!(obj instanceof Alias)) continue; + String objId = ((Alias)obj).getObjectId(); + if (markerId.equals(DeltaMarkerManager.SRC_SIDE_DELTA_MARKER)) { + srcSideIdSet.add(objId); + } else if (markerId.equals(DeltaMarkerManager.DST_SIDE_DELTA_MARKER)) { + dstSideIdSet.add(objId); + } + } catch (CoreException e) { + e.printStackTrace(); + } + } + } Set expandNodes = new HashSet<>(); Object obj = viewer.getTree().getTopItem().getData(); if (!(obj instanceof TreeNode)) return; @@ -182,9 +202,21 @@ expandParticularNodes(srcSideIdSet, dstSideIdSet, expandNodes, node); viewer.setExpandedElements(expandNodes.toArray(new Object[expandNodes.size()])); } + +// public void expandParticularNodes(Map> markerIdToObjectIdSet) { +// Set srcSideIdSet = new HashSet<>(markerIdToObjectIdSet.get(DeltaMarkerManager.DELTA_MARKER_ID)); +// Set dstSideIdSet = new HashSet<>(markerIdToObjectIdSet.get(DeltaMarkerManager.DELTA_MARKER_ID_2)); +// Set expandNodes = new HashSet<>(); +// Object obj = viewer.getTree().getTopItem().getData(); +// if (!(obj instanceof TreeNode)) return; +// TreeNode node = (TreeNode)obj; +// Object value = node.getValue(); +// if (!(value instanceof Variable)) return; +// expandParticularNodes(srcSideIdSet, dstSideIdSet, expandNodes, node); +// viewer.setExpandedElements(expandNodes.toArray(new Object[expandNodes.size()])); +// } private void expandParticularNodes(Set srcSideIdSet, Set dstSideIdSet, Set expandNodes, TreeNode node) { -// if (idSet.isEmpty()) return; Object value = node.getValue(); if (!(value instanceof Variable)) return; Variable variable = (Variable)value; diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java index 82e2b73..fd1db95 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java @@ -1,9 +1,9 @@ package org.ntlab.traceDebugger.analyzerProvider; +import java.util.HashMap; import java.util.List; +import java.util.Map; -import org.eclipse.core.resources.IFile; -import org.eclipse.core.resources.IMarker; import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldUpdate; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; import org.ntlab.traceAnalysisPlatform.tracer.trace.Reference; @@ -11,23 +11,19 @@ import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; -import org.ntlab.traceDebugger.JavaEditorOperator; +import org.ntlab.traceDebugger.DeltaMarkerView; import org.ntlab.traceDebugger.Variable; public class DeltaExtractionAnalyzer extends AbstractAnalyzer { private static DeltaExtractionAnalyzer theInstance = null; private DeltaExtractorJSON deltaExtractor; private ExtractedStructure extractedStructure; - private TracePoint bottomPoint; - private TracePoint coordinatorPoint; + private Map deltaMarkerViews = new HashMap<>(); public DeltaExtractionAnalyzer(Trace trace) { super(trace); deltaExtractor = new DeltaExtractorJSON((TraceJSON)trace); - DeltaMarkerManager mgr = DeltaMarkerManager.getInstance(); - mgr.deleteMarkers(DeltaMarkerManager.DELTA_MARKER_ID); - mgr.deleteMarkers(DeltaMarkerManager.DELTA_MARKER_ID_2); - mgr.deleteMarkerIdToObjectIdSet(); + reset(); } private static DeltaExtractionAnalyzer getInstance() { @@ -37,19 +33,12 @@ return theInstance; } - public TracePoint getBottomPoint() { - return bottomPoint; - } - - public TracePoint getCoordinatorPoint() { - return coordinatorPoint; - } - public ExtractedStructure geExtractedStructure() { return extractedStructure; } - public void extractDelta(Variable variable) { + public void extractDelta(Variable variable, DeltaMarkerView deltaMarkerView, String deltaMarkerViewSubId) { + addDeltaMarkerView(deltaMarkerViewSubId, deltaMarkerView); String srcId = variable.getContainerId(); String srcClassName = variable.getContainerClassName(); String dstId = variable.getId(); @@ -58,47 +47,31 @@ Reference reference = new Reference(srcId, dstId, srcClassName, dstClassName); // �f���^���o - reset(); DeltaRelatedAliasCollector aliasCollector = new DeltaRelatedAliasCollector(srcId, dstId); extractedStructure = deltaExtractor.extract(reference, before.duplicate(), aliasCollector); MethodExecution creationCallTree = extractedStructure.getCreationCallTree(); List srcSideRelatedAliases = aliasCollector.getSrcSideRelatedAliases(); List dstSideRelatedAliases = aliasCollector.getDstSideRelatedAliases(); MethodExecution coordinator = extractedStructure.getCoordinator(); - bottomPoint = findTracePoint(reference, creationCallTree, before.getStatement().getTimeStamp()); - + TracePoint bottomPoint = findTracePoint(reference, creationCallTree, before.getStatement().getTimeStamp()); + deltaMarkerView.setBottomPoint(bottomPoint); + MethodExecution me = bottomPoint.getMethodExecution(); MethodExecution childMe = null; - coordinatorPoint = null; while (me != null) { childMe = me; me = me.getParent(); if (coordinator.equals(me)) { - coordinatorPoint = childMe.getCallerTracePoint(); + TracePoint coordinatorPoint = childMe.getCallerTracePoint(); + deltaMarkerView.setCoordinatorPoint(coordinatorPoint); break; } } // �f���^���o�̌��ʂ����Ƀ\�[�X�R�[�h�𔽓]�\������ - mark(bottomPoint, srcSideRelatedAliases, dstSideRelatedAliases, coordinator); - } - - private void mark(TracePoint bottomPoint, List srcSideRelatedAliases, List dstSideRelatedAliases, MethodExecution coordinator) { - String message = String.format("Bottom %s", ""); - markAndOpenJavaFile(bottomPoint.getMethodExecution(), bottomPoint.getStatement().getLineNo(), message, DeltaMarkerManager.DELTA_MARKER_ID); - int cnt = 1; - for (Alias alias: srcSideRelatedAliases) { - message = String.format("SrcSide%03d %s (id = %s)", cnt, alias.getAliasType().toString(), alias.getObjectId()); - markAndOpenJavaFile(alias, message, DeltaMarkerManager.DELTA_MARKER_ID); - cnt++; - } - cnt = 1; - for (Alias alias : dstSideRelatedAliases) { - message = String.format("DstSide%03d %s (id = %s)", cnt, alias.getAliasType().toString(), alias.getObjectId()); - markAndOpenJavaFile(alias, message, DeltaMarkerManager.DELTA_MARKER_ID_2); - cnt++; - } - markAndOpenJavaFile(coordinator, -1 , "Coordinator", DeltaMarkerManager.DELTA_MARKER_ID); + DeltaMarkerManager mgr = deltaMarkerView.getDeltaMarkerManager(); + mark(mgr, bottomPoint, srcSideRelatedAliases, dstSideRelatedAliases, coordinator); + deltaMarkerView.update(); } private TracePoint findTracePoint(Reference reference, MethodExecution methodExecution, long beforeTime) { @@ -115,26 +88,37 @@ } return null; } - + + private void mark(DeltaMarkerManager mgr, TracePoint bottomPoint, List srcSideRelatedAliases, List dstSideRelatedAliases, MethodExecution coordinator) { + mgr.markAndOpenJavaFile(bottomPoint, "Bottom", DeltaMarkerManager.BOTTOM_DELTA_MARKER); + mgr.markAndOpenJavaFile(coordinator, -1 , "Coordinator", DeltaMarkerManager.COORDINATOR_DELTA_MARKER); + int cnt = 1; + for (Alias alias: srcSideRelatedAliases) { + String message = String.format("SrcSide%03d", cnt); + mgr.markAndOpenJavaFile(alias, message, DeltaMarkerManager.SRC_SIDE_DELTA_MARKER); + cnt++; + } + cnt = 1; + for (Alias alias : dstSideRelatedAliases) { + String message = String.format("DstSide%03d", cnt); + mgr.markAndOpenJavaFile(alias, message, DeltaMarkerManager.DST_SIDE_DELTA_MARKER); + cnt++; + } + } + private void reset() { - bottomPoint = null; - DeltaMarkerManager mgr = DeltaMarkerManager.getInstance(); - mgr.deleteMarkers(DeltaMarkerManager.DELTA_MARKER_ID); - mgr.deleteMarkers(DeltaMarkerManager.DELTA_MARKER_ID_2); - mgr.deleteMarkerIdToObjectIdSet(); + for (DeltaMarkerView deltaMarkerView : deltaMarkerViews.values()) { + deltaMarkerView.getDeltaMarkerManager().clearAllMarkers(); + } + deltaMarkerViews.clear(); + } + + private void addDeltaMarkerView(String subId, DeltaMarkerView deltaMarkerView) { + deltaMarkerView.setSubId(subId); + deltaMarkerViews.put(subId, deltaMarkerView); } - private void markAndOpenJavaFile(Alias alias, String message, String markerId) { - IFile file = JavaEditorOperator.findIFile(alias.getMethodExecution()); - DeltaMarkerManager mgr = DeltaMarkerManager.getInstance(); - IMarker marker = mgr.addMarker(alias, file, message, markerId); - JavaEditorOperator.markAndOpenJavaFile(marker); - } - - private void markAndOpenJavaFile(MethodExecution methodExecution, int lineNo, String message, String markerId) { - IFile file = JavaEditorOperator.findIFile(methodExecution); - DeltaMarkerManager mgr = DeltaMarkerManager.getInstance(); - IMarker marker = mgr.addMarker(methodExecution, lineNo, file, message, markerId); - JavaEditorOperator.markAndOpenJavaFile(marker); + public String getNextDeltaMarkerSubId() { + return String.valueOf(deltaMarkerViews.size() + 1); } } \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java index eaa2f72..a4989b2 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java @@ -26,58 +26,119 @@ import org.eclipse.jface.text.BadLocationException; import org.eclipse.jface.text.IDocument; import org.eclipse.jface.text.IRegion; +import org.eclipse.jface.viewers.TreeNode; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.PlatformUI; import org.eclipse.ui.editors.text.FileDocumentProvider; +import org.eclipse.ui.ide.IDE; import org.eclipse.ui.part.FileEditorInput; import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayAccess; import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayCreate; import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldAccess; +import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldUpdate; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodInvocation; import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; import org.ntlab.traceDebugger.JavaEditorOperator; public class DeltaMarkerManager { - private static final DeltaMarkerManager theInstance = new DeltaMarkerManager(); private Map> markers = new HashMap<>(); - private Map> markerIdToObjectIdSet = new HashMap<>(); - public static final String DELTA_MARKER_ID = "org.ntlab.traceDebugger.deltaMarker"; - public static final String DELTA_MARKER_ID_2 = "org.ntlab.traceDebugger.deltaMarker2"; - - private DeltaMarkerManager() { - - } - - public static DeltaMarkerManager getInstance() { - return theInstance; - } + public static final String BOTTOM_DELTA_MARKER = "org.ntlab.traceDebugger.bottomDeltaMarker"; + public static final String COORDINATOR_DELTA_MARKER = "org.ntlab.traceDebugger.coordinatorDeltaMarker"; + public static final String SRC_SIDE_DELTA_MARKER = "org.ntlab.traceDebugger.srcSideDeltaMarker"; + public static final String DST_SIDE_DELTA_MARKER = "org.ntlab.traceDebugger.dstSideDeltaMarker"; public Map> getMarkers() { return markers; } - - public IMarker addMarker(Alias alias, IFile file, String message, String markerId) { -// idSet.add(alias.getObjectId()); - if (markerId.equals(DELTA_MARKER_ID)) { - Set objectIdSet = markerIdToObjectIdSet.get(DELTA_MARKER_ID); - if (objectIdSet == null) { - objectIdSet = new HashSet(); - markerIdToObjectIdSet.put(DELTA_MARKER_ID, objectIdSet); + + public List getMarkerList() { + List markerList = new ArrayList<>(); + List list; + list = markers.get(BOTTOM_DELTA_MARKER); + if (list != null) markerList.addAll(list); + list = markers.get(COORDINATOR_DELTA_MARKER); + if (list != null) markerList.addAll(list); + list = markers.get(SRC_SIDE_DELTA_MARKER); + if (list != null) markerList.addAll(list); + list = markers.get(DST_SIDE_DELTA_MARKER); + if (list != null) markerList.addAll(list); + return markerList; + } + + public TreeNode[] getMarkerTreeNodes() { + TreeNode[] roots = new TreeNode[] { + new TreeNode("Bottom"), + new TreeNode("Coordinator"), + new TreeNode("SrcSide"), + new TreeNode("DstSide") + }; + List srcSideTreeNodeList = new ArrayList<>(); + List dstSideTreeNodeList = new ArrayList<>(); + for (Map.Entry> entry : markers.entrySet()) { + String markerId = entry.getKey(); + for (IMarker marker : entry.getValue()) { + TreeNode node = new TreeNode(marker); + if (markerId.equals(BOTTOM_DELTA_MARKER)) { + node.setParent(roots[0]); + roots[0].setChildren(new TreeNode[] {node}); + } else if (markerId.equals(COORDINATOR_DELTA_MARKER)) { + node.setParent(roots[1]); + roots[1].setChildren(new TreeNode[] {node}); + } else if (markerId.equals(SRC_SIDE_DELTA_MARKER)) { + node.setParent(roots[2]); + srcSideTreeNodeList.add(node); + } else if (markerId.equals(DST_SIDE_DELTA_MARKER)) { + node.setParent(roots[3]); + dstSideTreeNodeList.add(node); + } } - objectIdSet.add(alias.getObjectId()); - } else if (markerId.equals(DELTA_MARKER_ID_2)) { - Set objectIdSet = markerIdToObjectIdSet.get(DELTA_MARKER_ID_2); - if (objectIdSet == null) { - objectIdSet = new HashSet(); - markerIdToObjectIdSet.put(DELTA_MARKER_ID_2, objectIdSet); - } - objectIdSet.add(alias.getObjectId()); } - + roots[2].setChildren(srcSideTreeNodeList.toArray(new TreeNode[srcSideTreeNodeList.size()])); + roots[3].setChildren(dstSideTreeNodeList.toArray(new TreeNode[dstSideTreeNodeList.size()])); + return roots; + } + + public void markAndOpenJavaFile(Alias alias, String message, String markerId) { + IFile file = JavaEditorOperator.findIFile(alias.getMethodExecution()); + IMarker marker = addMarker(alias, file, message, markerId); + JavaEditorOperator.markAndOpenJavaFile(marker); + } + + public void markAndOpenJavaFile(TracePoint tracePoint, String message, String markerId) { + MethodExecution me = tracePoint.getMethodExecution(); + Statement statement = tracePoint.getStatement(); + int lineNo = statement.getLineNo(); + String objectId = null; + String objectType = null; + if (statement instanceof FieldUpdate) { + FieldUpdate fu = ((FieldUpdate)statement); + objectId = fu.getContainerObjId() + " -> " + fu.getValueObjId(); + objectType = fu.getContainerClassName() + " -> " + fu.getValueClassName(); + } + IFile file = JavaEditorOperator.findIFile(me); + IMarker marker = addMarker(me, lineNo, file, message, objectId, objectType, markerId); + JavaEditorOperator.markAndOpenJavaFile(marker); + } + + public void markAndOpenJavaFile(MethodExecution methodExecution, int lineNo, String message, String markerId) { + IFile file = JavaEditorOperator.findIFile(methodExecution); + IMarker marker = addMarker(methodExecution, lineNo, file, message, null, null, markerId); + JavaEditorOperator.markAndOpenJavaFile(marker); + } + + public IMarker addMarker(Alias alias, IFile file, String message, String markerId) { try { IMarker marker = file.createMarker(markerId); Map attributes = new HashMap<>(); - setAttributesForAlias(attributes, alias, file, message, markerId); + setAttributesForAlias(attributes, alias, file, markerId); + attributes.put(IMarker.MESSAGE, message); attributes.put(IMarker.TRANSIENT, true); + attributes.put("data", alias); + attributes.put("objectId", alias.getObjectId()); + attributes.put("aliasType", alias.getAliasType()); marker.setAttributes(attributes); addMarker(markerId, marker); return marker; @@ -87,13 +148,16 @@ return null; } - public IMarker addMarker(MethodExecution me, int lineNo, IFile file, String message, String markerId) { + public IMarker addMarker(MethodExecution me, int lineNo, IFile file, String message, String objectId, String objectType, String markerId) { try { IMarker marker = file.createMarker(markerId); Map attributes = new HashMap<>(); setAttributesForMethodExecution(attributes, me, file, lineNo, markerId); attributes.put(IMarker.MESSAGE, message); attributes.put(IMarker.TRANSIENT, true); + attributes.put("data", me); + attributes.put("objectId", objectId); + attributes.put("objectType", objectType); marker.setAttributes(attributes); addMarker(markerId, marker); return marker; @@ -112,20 +176,11 @@ markerList.add(marker); } - private void setAttributesForAlias(final Map attributes, Alias alias, IFile file, String message, String markerId) { + private void setAttributesForAlias(final Map attributes, Alias alias, IFile file, String markerId) { try { FileEditorInput input = new FileEditorInput(file); FileDocumentProvider provider = new FileDocumentProvider(); - provider.connect(input); - String aliasType = alias.getAliasType().toString(); - String statement = ""; - try { - statement = alias.getOccurrencePoint().getStatement().toString(); // statement���Ȃ��ꍇ������ - } catch (ArrayIndexOutOfBoundsException e) { - // e.printStackTrace(); - } - System.out.println(aliasType + ": " + statement); - + provider.connect(input); ASTParser parser = ASTParser.newParser(AST.JLS10); MethodExecution methodExecution = alias.getMethodExecution(); IType type = JavaEditorOperator.findIType(methodExecution); @@ -142,7 +197,6 @@ } } } - attributes.put(IMarker.MESSAGE, message); } catch (CoreException e) { e.printStackTrace(); } @@ -678,25 +732,20 @@ } } - public void deleteMarkers(String markerId) { - List markerList = markers.get(markerId); - if (markerList == null) return; + private void deleteMarkers(List markerList) { for (IMarker marker : markerList) { try { marker.delete(); } catch (CoreException e) { e.printStackTrace(); } + } + } + + public void clearAllMarkers() { + for (List markerList: markers.values()) { + deleteMarkers(markerList); } - markerList.clear(); - markers.remove(markerId); - } - - public Map> getMarkerIdToObjectIdSet() { - return markerIdToObjectIdSet; - } - - public void deleteMarkerIdToObjectIdSet() { - markerIdToObjectIdSet.clear(); + markers.clear(); } }