diff --git a/plugin.xml b/plugin.xml index 41db483..670aa14 100644 --- a/plugin.xml +++ b/plugin.xml @@ -36,6 +36,14 @@ name="DeltaMarker" restorable="true"> + + diff --git a/src/org/ntlab/traceDebugger/CallStackModels.java b/src/org/ntlab/traceDebugger/CallStackModels.java index 0a77207..5a1efb2 100644 --- a/src/org/ntlab/traceDebugger/CallStackModels.java +++ b/src/org/ntlab/traceDebugger/CallStackModels.java @@ -7,6 +7,7 @@ import org.eclipse.jface.viewers.TreeNode; import org.ntlab.traceAnalysisPlatform.tracer.trace.IStatementVisitor; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; import org.ntlab.traceAnalysisPlatform.tracer.trace.ThreadInstance; import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; @@ -103,6 +104,16 @@ } } + public void highlight(MethodExecution methodExecution) { + String signature1 = methodExecution.getSignature(); + for (List callStackModels : allCallStacks.values()) { + for (CallStackModel callStackModel : callStackModels) { + String signature2 = callStackModel.getMethodExecution().getSignature(); + callStackModel.setHighlighting(signature1.equals(signature2)); + } + } + } + // public IStatementVisitor tmp(TracePoint tp) { //// return new CallStackVisitor(tp); // try { diff --git a/src/org/ntlab/traceDebugger/CallStackView.java b/src/org/ntlab/traceDebugger/CallStackView.java index f2c112f..fb58439 100644 --- a/src/org/ntlab/traceDebugger/CallStackView.java +++ b/src/org/ntlab/traceDebugger/CallStackView.java @@ -96,6 +96,7 @@ public void updateByTracePoint(TracePoint tp) { callStackModels.updateByTracePoint(tp); + refresh(); } public void refresh() { @@ -120,6 +121,11 @@ return callStackModels.getAllCallStacks(); } + public void highlight(MethodExecution methodExecution) { + callStackModels.highlight(methodExecution); + viewer.refresh(); + } + private IViewPart getOtherView(String viewId) { IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); try { diff --git a/src/org/ntlab/traceDebugger/CallTreeLabelProvider.java b/src/org/ntlab/traceDebugger/CallTreeLabelProvider.java new file mode 100644 index 0000000..377b031 --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallTreeLabelProvider.java @@ -0,0 +1,51 @@ +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.graphics.Color; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.PlatformUI; + +public class CallTreeLabelProvider extends LabelProvider implements IColorProvider { + @Override + public String getText(Object element) { + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof CallTreeModel) { + CallTreeModel callTreeModel = (CallTreeModel)value; + return callTreeModel.getCallTreeSignature(); + } + } + return ""; + } + + @Override + public Image getImage(Object element) { + if (element instanceof TreeNode) { + return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); + } + return null; + } + + @Override + public Color getForeground(Object element) { + return null; + } + + @Override + public Color getBackground(Object element) { + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof CallTreeModel) { + CallTreeModel callTreeModel = (CallTreeModel)value; + if (callTreeModel.isHighlighting()) { + return new Color(Display.getDefault(), 0, 192, 255); + } + } + } + return null; + } +} diff --git a/src/org/ntlab/traceDebugger/CallTreeModel.java b/src/org/ntlab/traceDebugger/CallTreeModel.java new file mode 100644 index 0000000..82e1af9 --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallTreeModel.java @@ -0,0 +1,62 @@ +package org.ntlab.traceDebugger; + +import java.util.ArrayList; +import java.util.List; + +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; + +public class CallTreeModel { + private MethodExecution methodExecution; + private boolean isHighlighting; + + public CallTreeModel(MethodExecution methodExecution) { + this.methodExecution = methodExecution; + } + + public MethodExecution getMethodExecution() { + return methodExecution; + } + + public String getSignature() { + return methodExecution.getSignature(); + } + + public String getCallTreeSignature() { + String signature = ""; + signature = getSignature(); + String objectType = methodExecution.getThisClassName(); + objectType = objectType.substring(objectType.lastIndexOf(".") + 1); + boolean isConstructor = methodExecution.isConstructor(); + String declaringType = Trace.getDeclaringType(signature, isConstructor); + declaringType = declaringType.substring(declaringType.lastIndexOf(".") + 1); + String methodName = Trace.getMethodName(signature); + String args = "(" + signature.split("\\(")[1]; + + StringBuilder sb = new StringBuilder(); + sb.append(objectType); + if (!declaringType.equals(objectType)) { + sb.append("(" + declaringType + ")"); + } + sb.append("." + methodName + args); + signature = sb.toString(); + return signature; + } + + public boolean isHighlighting() { + return isHighlighting; + } + + public void setHighlighting(boolean isHighlighting) { + this.isHighlighting = isHighlighting; + } + + public List getChildren() { + List children = methodExecution.getChildren(); + List childrenCallTreeModels = new ArrayList<>(); + for (MethodExecution child : children) { + childrenCallTreeModels.add(new CallTreeModel(child)); + } + return childrenCallTreeModels; + } +} diff --git a/src/org/ntlab/traceDebugger/CallTreeModels.java b/src/org/ntlab/traceDebugger/CallTreeModels.java new file mode 100644 index 0000000..463db53 --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallTreeModels.java @@ -0,0 +1,47 @@ +package org.ntlab.traceDebugger; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.jface.viewers.TreeNode; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; + +public class CallTreeModels { + private TreeNode[] roots; + private List callTreeModelList = new ArrayList<>(); + + public TreeNode[] getCallTreeModels() { + return roots; + } + + public List getCallTreeModelList() { + return callTreeModelList; + } + + public void update(MethodExecution from, MethodExecution to) { + reset(); + createCallTreeModels(roots, 0, from, to); + } + + private boolean createCallTreeModels(TreeNode[] nodes, int index, MethodExecution me, final MethodExecution theLast) { + CallTreeModel callTreeModel = new CallTreeModel(me); + nodes[index] = new TreeNode(callTreeModel); + callTreeModelList.add(callTreeModel); + if (me.equals(theLast)) return true; + List children = me.getChildren(); + TreeNode[] childNodes = new TreeNode[children.size()]; + nodes[index].setChildren(childNodes); + for (int i = 0; i < children.size(); i++) { + MethodExecution child = children.get(i); + boolean isTheLast = createCallTreeModels(childNodes, i, child, theLast); + childNodes[i].setParent(nodes[index]); + if (isTheLast) return true; + } + return false; + } + + public void reset() { + roots = new TreeNode[1]; + callTreeModelList.clear(); + } +} diff --git a/src/org/ntlab/traceDebugger/CallTreeView.java b/src/org/ntlab/traceDebugger/CallTreeView.java new file mode 100644 index 0000000..4e65b2f --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallTreeView.java @@ -0,0 +1,138 @@ +package org.ntlab.traceDebugger; + +import java.util.List; + +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.widgets.Composite; +import org.eclipse.ui.IViewPart; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.PlatformUI; +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.DeltaMarkerManager; + +public class CallTreeView extends ViewPart { + private TreeViewer viewer; + private CallTreeModels callTreeModels = new CallTreeModels(); + private String subId; + public static final String ID = "org.ntlab.traceDebugger.callTreeView"; + + public CallTreeView() { + // TODO Auto-generated constructor stub + System.out.println("callTreeView�N���X���������ꂽ��"); + } + + @Override + public void createPartControl(Composite parent) { + // TODO Auto-generated method stub + System.out.println("CallTreeView#createPartControl(Composite)���Ă΂ꂽ��!"); + viewer = new TreeViewer(parent); + viewer.setContentProvider(new TreeNodeContentProvider()); + viewer.setLabelProvider(new CallTreeLabelProvider()); + + // �I�������J�����ɑΉ����郁�\�b�h���s�̃\�[�X�t�@�C�����J�����郊�X�i�[��o�^���� + viewer.addSelectionChangedListener(new ISelectionChangedListener() { + @Override + public void selectionChanged(SelectionChangedEvent event) { + IStructuredSelection sel = (IStructuredSelection)event.getSelection(); + Object element = sel.getFirstElement(); + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof CallTreeModel) { + CallTreeModel callTreeModel = (CallTreeModel)value; + MethodExecution methodExecution = callTreeModel.getMethodExecution(); + TracePoint tp = methodExecution.getEntryPoint(); + JavaEditorOperator.openSrcFileOfMethodExecution(methodExecution, -1); + DeltaMarkerView deltaMarkerView = ((DeltaMarkerView)getOtherView(DeltaMarkerView.ID, subId)); + DeltaMarkerManager deltaMarkerManager = deltaMarkerView.getDeltaMarkerManager(); + CallStackView callStackView = (CallStackView)getOtherView(CallStackView.ID, null); + callStackView.updateByTracePoint(tp); + try { + Object coordinatorME = deltaMarkerManager.getCoordinatorDeltaMarker().getAttribute("data"); + if (coordinatorME instanceof MethodExecution) { + callStackView.highlight((MethodExecution)coordinatorME); + } + } catch (CoreException e) { + e.printStackTrace(); + } + VariableView variableView = ((VariableView)getOtherView(VariableView.ID, null)); + variableView.updateVariablesByTracePoint(tp, false); + variableView.markAndExpandVariablesByDeltaMarker(deltaMarkerManager.getMarkers()); + } + } + } + }); + createActions(); + createToolBar(); + createMenuBar(); + } + + @Override + public void setFocus() { + // TODO Auto-generated method stub + viewer.getControl().setFocus(); + } + + private void createActions() { + + } + + private void createToolBar() { + IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); + } + + private void createMenuBar() { + IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); + } + + public String getSubId() { + return subId; + } + + public void setSubId(String subId) { + this.subId = subId; + } + + public void update(MethodExecution from, MethodExecution to) { + callTreeModels.update(from, to); + viewer.setInput(callTreeModels.getCallTreeModels()); + viewer.expandAll(); + } + + public void highlight(MethodExecution theMe) { + List callTreeModelList = callTreeModels.getCallTreeModelList(); + for (CallTreeModel callTreeModel : callTreeModelList) { + MethodExecution me = callTreeModel.getMethodExecution(); + callTreeModel.setHighlighting(me.equals(theMe)); + } + viewer.refresh(); + } + + public void refresh() { + + } + + public void reset() { + + } + + private IViewPart getOtherView(String viewId, String subId) { + IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); + try { + if (subId == null) return workbenchPage.showView(viewId); + return workbenchPage.showView(viewId, subId, IWorkbenchPage.VIEW_ACTIVATE); + } catch (PartInitException e) { + throw new RuntimeException(e); + } + } +} diff --git a/src/org/ntlab/traceDebugger/DebuggingController.java b/src/org/ntlab/traceDebugger/DebuggingController.java index f2bd067..f4a4084 100644 --- a/src/org/ntlab/traceDebugger/DebuggingController.java +++ b/src/org/ntlab/traceDebugger/DebuggingController.java @@ -227,10 +227,10 @@ * ���݂̃f�o�b�O�ʒu���w�肵���g���[�X�|�C���g�ɍ��킹�� * @return */ - public boolean jumpToTheTracePoint(TracePoint tp) { + public boolean jumpToTheTracePoint(TracePoint tp, boolean isReturned) { if (tp == null) return false; debuggingTp = tp.duplicate(); - refresh(false); + refresh(isReturned); return true; } @@ -240,7 +240,6 @@ JavaEditorOperator.openSrcFileOfMethodExecution(me, lineNo); CallStackView callStackView = ((CallStackView)getOtherView(CallStackView.ID)); callStackView.updateByTracePoint(debuggingTp); - callStackView.refresh(); ((VariableView)getOtherView(VariableView.ID)).updateVariablesByTracePoint(debuggingTp, isReturned); } diff --git a/src/org/ntlab/traceDebugger/DeltaMarkerView.java b/src/org/ntlab/traceDebugger/DeltaMarkerView.java index 9b14d26..03ee013 100644 --- a/src/org/ntlab/traceDebugger/DeltaMarkerView.java +++ b/src/org/ntlab/traceDebugger/DeltaMarkerView.java @@ -1,7 +1,5 @@ package org.ntlab.traceDebugger; -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; @@ -26,6 +24,8 @@ 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.Alias.AliasType; + import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; public class DeltaMarkerView extends ViewPart { @@ -66,23 +66,38 @@ if (!(element instanceof TreeNode)) return; Object value = ((TreeNode)element).getValue(); if (!(value instanceof IMarker)) return; - IMarker marker = (IMarker)value; + IMarker selectionMarker = (IMarker)value; try { DebuggingController controller = DebuggingController.getInstance(); - Object obj = marker.getAttribute("data"); - TracePoint jumpPoint = coordinatorPoint; + Object obj = selectionMarker.getAttribute("data"); + TracePoint jumpPoint; + MethodExecution selectionME; + boolean isReturned = false; if (obj instanceof Alias) { - jumpPoint = ((Alias)obj).getOccurrencePoint(); + Alias alias = (Alias)obj; + jumpPoint = alias.getOccurrencePoint(); + selectionME = jumpPoint.getMethodExecution(); + Alias.AliasType type = alias.getAliasType(); + isReturned = type.equals(AliasType.METHOD_INVOCATION) + || type.equals(AliasType.CONSTRACTOR_INVOCATION); } else if (obj instanceof TracePoint) { jumpPoint = (TracePoint)obj; + selectionME = jumpPoint.getMethodExecution(); + } else { + jumpPoint = coordinatorPoint; + selectionME = coordinatorPoint.getMethodExecution(); } - controller.jumpToTheTracePoint(jumpPoint); - + controller.jumpToTheTracePoint(jumpPoint, isReturned); IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); - IDE.openEditor(page, marker); - highlightInCallStack(deltaMarkerManager.getCoordinatorDeltaMarker()); - VariableView variableView = (VariableView)getOtherView(VariableView.ID); - variableView.expandParticularNodes(deltaMarkerManager.getMarkers()); + IDE.openEditor(page, selectionMarker); + + CallStackView callStackView = (CallStackView)getOtherView(CallStackView.ID, null); + callStackView.highlight(coordinatorPoint.getMethodExecution()); + VariableView variableView = (VariableView)getOtherView(VariableView.ID, null); + variableView.markAndExpandVariablesByDeltaMarker(deltaMarkerManager.getMarkers()); + CallTreeView callTreeView = ((CallTreeView)getOtherView(CallTreeView.ID, null)); +// CallTreeView callTreeView = ((CallTreeView)getOtherView(CallTreeView.ID, subId)); + callTreeView.highlight(selectionME); setFocus(); } catch (CoreException e) { e.printStackTrace(); @@ -153,40 +168,16 @@ this.coordinatorPoint = coordinatorPoint; } - private void highlightInCallStack(IMarker marker) { - CallStackView callStackView = (CallStackView)getOtherView(CallStackView.ID); - try { - Object obj = marker.getAttribute("data"); - String signature1 = ""; - if (obj instanceof Alias) { - signature1 = ((Alias)obj).getMethodSignature(); - } else if (obj instanceof TracePoint) { - signature1 = ((TracePoint)obj).getMethodExecution().getCallerSideSignature(); - } 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) { + private IViewPart getOtherView(String viewId, String subId) { IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); try { - return workbenchPage.showView(viewId); + if (subId == null) return workbenchPage.showView(viewId); + return workbenchPage.showView(viewId, subId, IWorkbenchPage.VIEW_ACTIVATE); } catch (PartInitException e) { throw new RuntimeException(e); } diff --git a/src/org/ntlab/traceDebugger/Variable.java b/src/org/ntlab/traceDebugger/Variable.java index 92e415e..00afc17 100644 --- a/src/org/ntlab/traceDebugger/Variable.java +++ b/src/org/ntlab/traceDebugger/Variable.java @@ -4,7 +4,9 @@ import java.util.Arrays; import java.util.Collections; import java.util.Comparator; +import java.util.HashMap; import java.util.List; +import java.util.Map; import org.eclipse.jdt.core.Flags; import org.eclipse.jdt.core.IField; @@ -29,8 +31,7 @@ private DeepHierarchy deepHierarchy; private boolean alreadyCreatedChildHierarchy = false; private boolean alreadyCreatedGrandChildHierarchy = false; - private boolean isSrcSideRelatedDelta = false; - private boolean isDstSideRelatedDelta = false; + private Map additionalAttributes = new HashMap<>(); public Variable(String variableName, String containerClassName, String containerId, String className, String id, TracePoint before, boolean isReturned) { @@ -221,23 +222,14 @@ } } - public boolean isSrcSideRelatedDelta() { - return isSrcSideRelatedDelta; + public void addAdditionalAttribute(String key, Object value) { + additionalAttributes.put(key, value); } - public void setSrcSideRelatedDelta(boolean isSrcSideRelatedDelta) { - this.isSrcSideRelatedDelta = isSrcSideRelatedDelta; + public Object getAdditionalAttribute(String key) { + return additionalAttributes.get(key); } - - public boolean isDstSideRelatedDelta() { - return isDstSideRelatedDelta; - } - - public void setDstSideRelatedDelta(boolean isDstSideRelatedDelta) { - this.isDstSideRelatedDelta = isDstSideRelatedDelta; - } - - + private enum DeepHierarchy { NONE, FIELD, ARRAY; } diff --git a/src/org/ntlab/traceDebugger/VariableLabelProvider.java b/src/org/ntlab/traceDebugger/VariableLabelProvider.java index 5fcbf39..d70d776 100644 --- a/src/org/ntlab/traceDebugger/VariableLabelProvider.java +++ b/src/org/ntlab/traceDebugger/VariableLabelProvider.java @@ -10,6 +10,7 @@ import org.eclipse.swt.widgets.Display; import org.eclipse.ui.ISharedImages; import org.eclipse.ui.PlatformUI; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; public class VariableLabelProvider extends LabelProvider implements ITableLabelProvider, ITableColorProvider { @Override @@ -56,11 +57,15 @@ Object value = ((TreeNode)element).getValue(); if (value instanceof Variable) { Variable variable = (Variable)value; - if (variable.isSrcSideRelatedDelta()) { + Object markerId = variable.getAdditionalAttribute("markerId"); + if (!(markerId instanceof String)) return null; + switch ((String)markerId) { + case DeltaMarkerManager.SRC_SIDE_DELTA_MARKER: return new Color(Display.getDefault(), 255, 128, 0); - } - if (variable.isDstSideRelatedDelta()) { - return Display.getDefault().getSystemColor(SWT.COLOR_CYAN); + case DeltaMarkerManager.DST_SIDE_DELTA_MARKER: + return Display.getDefault().getSystemColor(SWT.COLOR_CYAN); + case DeltaMarkerManager.COORDINATOR_DELTA_MARKER: + return Display.getDefault().getSystemColor(SWT.COLOR_GREEN); } } } diff --git a/src/org/ntlab/traceDebugger/VariableView.java b/src/org/ntlab/traceDebugger/VariableView.java index 4a54e4b..e596a89 100644 --- a/src/org/ntlab/traceDebugger/VariableView.java +++ b/src/org/ntlab/traceDebugger/VariableView.java @@ -1,5 +1,6 @@ package org.ntlab.traceDebugger; +import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; @@ -27,6 +28,7 @@ import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.Tree; import org.eclipse.swt.widgets.TreeColumn; +import org.eclipse.swt.widgets.TreeItem; import org.eclipse.ui.IViewPart; import org.eclipse.ui.IWorkbench; import org.eclipse.ui.IWorkbenchActionConstants; @@ -34,6 +36,7 @@ import org.eclipse.ui.PartInitException; import org.eclipse.ui.PlatformUI; 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.AbstractAnalyzer; import org.ntlab.traceDebugger.analyzerProvider.Alias; @@ -134,7 +137,7 @@ TracePoint tp = selectedVariable.getLastUpdatePoint(); if (tp == null) return; DebuggingController controller = DebuggingController.getInstance(); - controller.jumpToTheTracePoint(tp); + controller.jumpToTheTracePoint(tp, false); controller.stepOverAction(); } }; @@ -151,14 +154,23 @@ IWorkbenchPage workbenchPage = workbench.getActiveWorkbenchWindow().getActivePage(); try { // note: ����r���[�𕡐��J���e�X�g - String newDeltaMarkerViewSubId = deltaAnalyzer.getNextDeltaMarkerSubId(); - DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)workbenchPage.showView(DeltaMarkerView.ID, newDeltaMarkerViewSubId, IWorkbenchPage.VIEW_ACTIVATE); - deltaAnalyzer.extractDelta(selectedVariable, newDeltaMarkerView, newDeltaMarkerViewSubId); + String subIdWithNewView = deltaAnalyzer.getNextDeltaMarkerSubId(); + DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)workbenchPage.showView(DeltaMarkerView.ID, subIdWithNewView, IWorkbenchPage.VIEW_ACTIVATE); + deltaAnalyzer.extractDelta(selectedVariable, newDeltaMarkerView, subIdWithNewView); TracePoint coordinatorPoint = newDeltaMarkerView.getCoordinatorPoint(); DebuggingController controller = DebuggingController.getInstance(); - controller.jumpToTheTracePoint(coordinatorPoint); + controller.jumpToTheTracePoint(coordinatorPoint, false); + DeltaMarkerManager deltaMarkerManager = newDeltaMarkerView.getDeltaMarkerManager(); - expandParticularNodes(deltaMarkerManager.getMarkers()); + markAndExpandVariablesByDeltaMarker(deltaMarkerManager.getMarkers()); + MethodExecution coordinatorME = coordinatorPoint.getMethodExecution(); + MethodExecution bottomME = newDeltaMarkerView.getBottomPoint().getMethodExecution(); + CallStackView callStackView = (CallStackView)getOtherView(CallStackView.ID); + callStackView.highlight(coordinatorME); + CallTreeView callTreeView = (CallTreeView)getOtherView(CallTreeView.ID); + callTreeView.setSubId(subIdWithNewView); + callTreeView.update(coordinatorME, bottomME); + callTreeView.highlight(coordinatorME); } catch (PartInitException e) { e.printStackTrace(); } @@ -169,64 +181,6 @@ deltaAction.setToolTipText("Extract Delta"); } - 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; - 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) { - Object value = node.getValue(); - if (!(value instanceof Variable)) return; - Variable variable = (Variable)value; - String id = variable.getId(); - if (srcSideIdSet.contains(id)) { - variable.setSrcSideRelatedDelta(true); - srcSideIdSet.remove(id); - TreeNode parent = node.getParent(); - if (parent != null) { - expandNodes.add(node.getParent()); - } - } else if (dstSideIdSet.contains(id)) { - variable.setDstSideRelatedDelta(true); - dstSideIdSet.remove(id); - TreeNode parent = node.getParent(); - if (parent != null) { - expandNodes.add(node.getParent()); - } - } - TreeNode[] children = node.getChildren(); - if (children == null) return; - for (TreeNode child : children) { - expandParticularNodes(srcSideIdSet, dstSideIdSet, expandNodes, child); - } - } - private void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); } @@ -258,10 +212,67 @@ } public void updateVariablesByTracePoint(TracePoint tp, boolean isReturned) { - variables.getAllObjectDataByTracePoint(tp, isReturned); + variables.updateAllObjectDataByTracePoint(tp, isReturned); viewer.setInput(variables.getVariablesTreeNodes()); } + public void markAndExpandVariablesByDeltaMarker(Map> markers) { + List srcSideDeltaMarkers = markers.get(DeltaMarkerManager.SRC_SIDE_DELTA_MARKER); + List dstSideDeltaMarkers = markers.get(DeltaMarkerManager.DST_SIDE_DELTA_MARKER); + List coordinatorMarker = markers.get(DeltaMarkerManager.COORDINATOR_DELTA_MARKER); + markVariables(DeltaMarkerManager.SRC_SIDE_DELTA_MARKER, srcSideDeltaMarkers); + markVariables(DeltaMarkerManager.DST_SIDE_DELTA_MARKER, dstSideDeltaMarkers); + markVariables(DeltaMarkerManager.COORDINATOR_DELTA_MARKER, coordinatorMarker); + viewer.refresh(); + expandAllMarkedNodes(); + } + + private void markVariables(String markerId, List markerList) { + Set idSet = new HashSet<>(); + Map additionalAttributesForVariables = new HashMap<>(); + additionalAttributesForVariables.put("markerId", markerId); + for (IMarker marker : markerList) { + try { + Object data = marker.getAttribute("data"); + if (data instanceof Alias) { + idSet.add(((Alias)data).getObjectId()); + } else if (data instanceof MethodExecution) { + idSet.add(((MethodExecution)data).getThisObjId()); + } + } catch (CoreException e) { + e.printStackTrace(); + } + } + variables.addAdditionalAttributes(idSet, additionalAttributesForVariables); + } + + private void expandAllMarkedNodes() { + Set expandedNodes = new HashSet<>(); + for (TreeItem item : viewer.getTree().getItems()) { + Object obj = item.getData(); + if (!(obj instanceof TreeNode)) continue; + expandMarkedNodes((TreeNode)obj, expandedNodes); + } + viewer.setExpandedElements(expandedNodes.toArray(new Object[expandedNodes.size()])); + } + + private void expandMarkedNodes(TreeNode node, final Set expandedNodes) { + Object value = node.getValue(); + if (!(value instanceof Variable)) return; + Variable variable = (Variable)value; + if (variable.getAdditionalAttribute("markerId") != null) { + TreeNode parent = node.getParent(); + if (parent != null) { + expandedNodes.add(parent); + } + } + TreeNode[] children = node.getChildren(); + if (children == null) return; + for (TreeNode child : children) { + expandMarkedNodes(child, expandedNodes); + } + } + private IViewPart getOtherView(String viewId) { IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); try { diff --git a/src/org/ntlab/traceDebugger/Variables.java b/src/org/ntlab/traceDebugger/Variables.java index 211ba3e..c73dd67 100644 --- a/src/org/ntlab/traceDebugger/Variables.java +++ b/src/org/ntlab/traceDebugger/Variables.java @@ -2,6 +2,8 @@ import java.util.ArrayList; import java.util.List; +import java.util.Map; +import java.util.Set; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IType; @@ -14,24 +16,22 @@ public class Variables { private static final Variables theInstance = new Variables(); - private Variable rootThisObjData; - private List argsData = new ArrayList<>(); - private List allObjData = new ArrayList<>(); + private List roots = new ArrayList<>(); public static Variables getInstance() { return theInstance; } public TreeNode[] getVariablesTreeNodes() { - TreeNode[] roots = new TreeNode[allObjData.size()]; - if (allObjData.isEmpty()) { - return roots; + TreeNode[] rootNodes = new TreeNode[roots.size()]; + if (roots.isEmpty()) { + return rootNodes; } - for (int i = 0; i < allObjData.size(); i++) { - Variable rootVariableData = allObjData.get(i); - createVariablesTreeNode(null, roots, i, rootVariableData); + for (int i = 0; i < roots.size(); i++) { + Variable rootVariableData = roots.get(i); + createVariablesTreeNode(null, rootNodes, i, rootVariableData); } - return roots; + return rootNodes; } private void createVariablesTreeNode(TreeNode parentNode, TreeNode[] addingNodes, int index, Variable addingVariableData) { @@ -46,45 +46,38 @@ } } - public List getAllObjectDataByMethodExecution(MethodExecution methodExecution) { - if (methodExecution == null) return new ArrayList<>(); + public void updateAllObjectDataByMethodExecution(MethodExecution methodExecution) { + if (methodExecution == null) return; List statements = methodExecution.getStatements(); int lastOrder = statements.size() - 1; TracePoint tp = methodExecution.getTracePoint(lastOrder); - getAllObjectData(methodExecution, tp, false); - return allObjData; + updateAllObjectData(methodExecution, tp, false); } - public List getAllObjectDataByTracePoint(TracePoint tp, boolean isReturned) { + public void updateAllObjectDataByTracePoint(TracePoint tp, boolean isReturned) { MethodExecution methodExecution = tp.getMethodExecution(); - getAllObjectData(methodExecution, tp, isReturned); - return allObjData; + updateAllObjectData(methodExecution, tp, isReturned); } public void resetData() { - rootThisObjData = null; - argsData.clear(); - allObjData.clear(); + roots.clear(); } - private void getAllObjectData(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { + private void updateAllObjectData(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { resetData(); - getRootThisState(methodExecution, tp, isReturned); - getArgsState(methodExecution, tp, isReturned); - allObjData.add(rootThisObjData); - for (Variable argData : argsData) { - allObjData.add(argData); - } + updateRootThisState(methodExecution, tp, isReturned); + updateArgsState(methodExecution, tp, isReturned); } - private void getRootThisState(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { + private void updateRootThisState(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { String thisObjId = methodExecution.getThisObjId(); String thisClassName = methodExecution.getThisClassName(); - rootThisObjData = new Variable("this", null, null, thisClassName, thisObjId, tp, isReturned); - rootThisObjData.createNextHierarchyState(); + Variable variable = new Variable("this", null, null, thisClassName, thisObjId, tp, isReturned); + roots.add(variable); + variable.createNextHierarchyState(); } - private void getArgsState(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { + private void updateArgsState(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { // methodExecution������arguments���擾(ArrayList)���A����arguments�̃T�C�Y���擾(int) List args = methodExecution.getArguments(); if (args.size() > 0) { @@ -99,7 +92,7 @@ String argType = arg.getActualType(); Variable argData = new Variable(argName, null, null, argType, argId, tp, isReturned); argData.createNextHierarchyState(); - argsData.add(argData); + roots.add(argData); } } } @@ -114,5 +107,23 @@ } } return argNames; - } + } + + public void addAdditionalAttributes(final Set idSet, final Map additionalAttributes) { + for (Variable root : roots) { + addAdditionalAttributes(root, idSet, additionalAttributes); + } + } + + private void addAdditionalAttributes(Variable variable, final Set idSet, final Map additionalAttributes) { + if (variable == null) return; + if (idSet.contains(variable.getId())) { + for (Map.Entry entry : additionalAttributes.entrySet()) { + variable.addAdditionalAttribute(entry.getKey(), entry.getValue()); + } + } + for (Variable child : variable.getChildren()) { + addAdditionalAttributes(child, idSet, additionalAttributes); + } + } }