diff --git a/.classpath b/.classpath index 5d953bc..a761d0b 100644 --- a/.classpath +++ b/.classpath @@ -1,5 +1,6 @@ + diff --git a/META-INF/MANIFEST.MF b/META-INF/MANIFEST.MF index 4ef7b30..eb87d3b 100644 --- a/META-INF/MANIFEST.MF +++ b/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: TraceDebugger -Bundle-SymbolicName: org.ntlab.traceDebugger3;singleton:=true +Bundle-SymbolicName: org.ntlab.traceDebugger;singleton:=true Bundle-Version: 1.0.0.qualifier Automatic-Module-Name: org.ntlab.objectFlowAnalyzer2 Require-Bundle: org.eclipse.ui;bundle-version="3.109.100", @@ -13,4 +13,10 @@ org.ntlab.traceAnalysisPlatform;bundle-version="1.0.0", org.eclipse.ui.editors;bundle-version="3.11.100", org.eclipse.jface.text;bundle-version="3.13.0", - org.eclipse.ui.ide;bundle-version="3.14.0" + org.eclipse.ui.ide;bundle-version="3.14.0", + org.eclipse.text, + org.eclipse.debug.ui;bundle-version="3.13.0" +Bundle-Activator: org.ntlab.traceDebugger.TraceDebuggerPlugin +Bundle-ActivationPolicy: lazy +Bundle-ClassPath: icons/, + . diff --git a/bin/.gitignore b/bin/.gitignore new file mode 100644 index 0000000..cf1db2e --- /dev/null +++ b/bin/.gitignore @@ -0,0 +1 @@ +/org/ diff --git a/bin/org/ntlab/traceDebugger/DebuggingController.class b/bin/org/ntlab/traceDebugger/DebuggingController.class index 47c1e53..fd30e35 100644 --- a/bin/org/ntlab/traceDebugger/DebuggingController.class +++ b/bin/org/ntlab/traceDebugger/DebuggingController.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/JavaEditorOperator.class b/bin/org/ntlab/traceDebugger/JavaEditorOperator.class index e3a0a70..a650bcc 100644 --- a/bin/org/ntlab/traceDebugger/JavaEditorOperator.class +++ b/bin/org/ntlab/traceDebugger/JavaEditorOperator.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/TraceDebuggerPlugin.class b/bin/org/ntlab/traceDebugger/TraceDebuggerPlugin.class index 394c546..5e005bf 100644 --- a/bin/org/ntlab/traceDebugger/TraceDebuggerPlugin.class +++ b/bin/org/ntlab/traceDebugger/TraceDebuggerPlugin.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/Alias.class b/bin/org/ntlab/traceDebugger/analyzerProvider/Alias.class index 17ae051..6895cd8 100644 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/Alias.class +++ b/bin/org/ntlab/traceDebugger/analyzerProvider/Alias.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.class b/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.class index c7fa7f9..e7347ae 100644 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.class +++ b/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.class b/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.class index bc13fb4..6fde5b1 100644 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.class +++ b/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.class b/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.class index e6da5b6..5d55faa 100644 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.class +++ b/bin/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.class b/bin/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.class index f01bc15..3bda7b5 100644 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.class +++ b/bin/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.class Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzer.class b/bin/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzer.class deleted file mode 100644 index d425f31..0000000 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzer.class +++ /dev/null Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzerLaunchConfiguration.class b/bin/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzerLaunchConfiguration.class deleted file mode 100644 index dfe2ec5..0000000 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzerLaunchConfiguration.class +++ /dev/null Binary files differ diff --git a/bin/org/ntlab/traceDebugger/analyzerProvider/ReferencePoint.class b/bin/org/ntlab/traceDebugger/analyzerProvider/ReferencePoint.class deleted file mode 100644 index 8c0eb7e..0000000 --- a/bin/org/ntlab/traceDebugger/analyzerProvider/ReferencePoint.class +++ /dev/null Binary files differ diff --git a/build.properties b/build.properties index 6f20375..285b8bf 100644 --- a/build.properties +++ b/build.properties @@ -2,4 +2,5 @@ output.. = bin/ bin.includes = META-INF/,\ .,\ - plugin.xml + plugin.xml,\ + icons/ diff --git a/icons/debug/backresume_dlcl.png b/icons/debug/backresume_dlcl.png new file mode 100644 index 0000000..34fd6af --- /dev/null +++ b/icons/debug/backresume_dlcl.png Binary files differ diff --git a/icons/debug/backresume_elcl.png b/icons/debug/backresume_elcl.png new file mode 100644 index 0000000..42655d4 --- /dev/null +++ b/icons/debug/backresume_elcl.png Binary files differ diff --git a/icons/debug/stepbackinto_dlcl.png b/icons/debug/stepbackinto_dlcl.png new file mode 100644 index 0000000..a662a48 --- /dev/null +++ b/icons/debug/stepbackinto_dlcl.png Binary files differ diff --git a/icons/debug/stepbackinto_elcl.png b/icons/debug/stepbackinto_elcl.png new file mode 100644 index 0000000..c745a71 --- /dev/null +++ b/icons/debug/stepbackinto_elcl.png Binary files differ diff --git a/icons/debug/stepbackover_dlcl.png b/icons/debug/stepbackover_dlcl.png new file mode 100644 index 0000000..7b98085 --- /dev/null +++ b/icons/debug/stepbackover_dlcl.png Binary files differ diff --git a/icons/debug/stepbackover_elcl.png b/icons/debug/stepbackover_elcl.png new file mode 100644 index 0000000..c39dc97 --- /dev/null +++ b/icons/debug/stepbackover_elcl.png Binary files differ diff --git a/icons/debug/stepbackreturn_dlcl.png b/icons/debug/stepbackreturn_dlcl.png new file mode 100644 index 0000000..537eb0a --- /dev/null +++ b/icons/debug/stepbackreturn_dlcl.png Binary files differ diff --git a/icons/debug/stepbackreturn_elcl.png b/icons/debug/stepbackreturn_elcl.png new file mode 100644 index 0000000..7e565e6 --- /dev/null +++ b/icons/debug/stepbackreturn_elcl.png Binary files differ diff --git a/plugin.xml b/plugin.xml index f3e94ef..2de2e99 100644 --- a/plugin.xml +++ b/plugin.xml @@ -9,23 +9,71 @@ + + + + + + + + + + + + + + @@ -34,21 +82,70 @@ + name="TraceDebugger (Forward)"> + + + class="org.ntlab.traceDebugger.analyzerProvider.DeltaExtractionAnalyzerLaunchConfiguration"> + value="false"> + + + + + + + + + + + + + + + + + + + + + + + + @@ -58,34 +155,183 @@ point="org.eclipse.ui.ide.markerImageProviders"> + id="BottomDeltaMarker" + markertype="org.ntlab.traceDebugger.bottomDeltaMarker"> + + + + + + + + + + + + + + + + + textStylePreferenceValue="BOX" + verticalRulerPreferenceKey="clvertical" + verticalRulerPreferenceValue="true"> + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/org/ntlab/traceDebugger/BreakPointLabelProvider.java b/src/org/ntlab/traceDebugger/BreakPointLabelProvider.java index 92bd644..e39696c 100644 --- a/src/org/ntlab/traceDebugger/BreakPointLabelProvider.java +++ b/src/org/ntlab/traceDebugger/BreakPointLabelProvider.java @@ -14,11 +14,12 @@ TraceBreakPoint tbp = (TraceBreakPoint)element; switch (columnIndex) { case 0: - return tbp.isAvailable() ? "True" : "False"; +// return tbp.isAvailable() ? "True" : "False"; + return ""; case 1: return String.valueOf(tbp.getLineNo()); case 2: - return tbp.getMethodSignature(); + return tbp.getReadableSignature(); } } return "�e�X�g�p�e�L�X�g" + columnIndex; @@ -26,6 +27,7 @@ @Override public Image getColumnImage(Object element, int columnIndex) { + if (columnIndex == 0) return null; return getImage(element); } diff --git a/src/org/ntlab/traceDebugger/BreakPointView.java b/src/org/ntlab/traceDebugger/BreakPointView.java index 89c5f79..d444aaa 100644 --- a/src/org/ntlab/traceDebugger/BreakPointView.java +++ b/src/org/ntlab/traceDebugger/BreakPointView.java @@ -1,5 +1,10 @@ package org.ntlab.traceDebugger; +import java.util.ArrayList; + +import org.eclipse.debug.internal.ui.IInternalDebugUIConstants; +import org.eclipse.debug.ui.DebugUITools; +import org.eclipse.debug.ui.IDebugUIConstants; import org.eclipse.jface.action.Action; import org.eclipse.jface.action.IAction; import org.eclipse.jface.action.IMenuListener; @@ -9,16 +14,24 @@ import org.eclipse.jface.action.Separator; import org.eclipse.jface.resource.ImageDescriptor; import org.eclipse.jface.viewers.ArrayContentProvider; +import org.eclipse.jface.viewers.CheckboxTableViewer; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.Viewer; import org.eclipse.swt.SWT; +import org.eclipse.swt.events.MouseAdapter; +import org.eclipse.swt.events.MouseEvent; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.graphics.Point; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Table; import org.eclipse.swt.widgets.TableColumn; +import org.eclipse.swt.widgets.TableItem; import org.eclipse.ui.ISharedImages; import org.eclipse.ui.IWorkbenchActionConstants; import org.eclipse.ui.PlatformUI; @@ -26,24 +39,22 @@ import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; public class BreakPointView extends ViewPart { - private TableViewer viewer; - private IAction fileOpenAction; - private IAction addTraceBreakPointAction; - private IAction removeTraceBreakPointAction; - private IAction changeAvailableAction; - private IAction debugAction; - private IAction terminateAction; - private IAction stepIntoAction; - private IAction stepOverAction; - private IAction stepReturnAction; - private IAction resumeAction; - private IAction stepBackIntoAction; - private IAction stepBackOverAction; - private IAction stepBackReturnAction; - private IAction backResumeAction; - private IAction tmpAction; - private Shell shell; - private DebuggingController debuggingController = new DebuggingController(); + protected TableViewer viewer; + protected IAction fileOpenAction; + protected IAction addTraceBreakPointAction; + protected IAction removeTraceBreakPointAction; + protected IAction changeAvailableAction; + protected IAction debugAction; + protected IAction terminateAction; + protected IAction stepIntoAction; + protected IAction stepOverAction; + protected IAction stepReturnAction; + protected IAction stepNextAction; + protected IAction resumeAction; + protected IAction importBreakpointAction; + protected Shell shell; + protected TraceBreakPoints traceBreakPoints; + protected DebuggingController debuggingController = DebuggingController.getInstance(); public static final String ID = "org.ntlab.traceDebugger.breakPointView"; public BreakPointView() { @@ -56,14 +67,14 @@ // TODO Auto-generated method stub System.out.println("BreakPointView#createPartControl(Composite)���Ă΂ꂽ��!"); shell = parent.getShell(); - viewer = new TableViewer(parent, SWT.FULL_SELECTION); - Table table = viewer.getTable(); + viewer = CheckboxTableViewer.newCheckList(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.FULL_SELECTION); + final Table table = viewer.getTable(); table.setHeaderVisible(true); table.setLinesVisible(true); // �e�[�u���̃J�������쐬 - String[] tableColumnTexts = {"Available", "Line No", "Signature"}; - int[] tableColumnWidth = {80, 80, 200}; + String[] tableColumnTexts = {"", "Line", "Signature"}; + int[] tableColumnWidth = {30, 80, 500}; TableColumn[] tableColumns = new TableColumn[tableColumnTexts.length]; for (int i = 0; i < tableColumns.length; i++) { tableColumns[i] = new TableColumn(table, SWT.NULL); @@ -88,20 +99,41 @@ } } }); + + table.addMouseListener(new MouseAdapter() { + @Override + public void mouseDown(MouseEvent e) { + Point point = new Point(e.x, e.y); + TableItem item = table.getItem(point); + if (item == null) return; + boolean checked = item.getChecked(); + Object data = item.getData(); + if (data instanceof TraceBreakPoint) { + TraceBreakPoint tbp = (TraceBreakPoint)data; + tbp.setAvailable(checked); + } + } + }); createActions(); createToolBar(); createMenuBar(); createPopupMenu(); + TraceDebuggerPlugin.setActiveView(ID, this); } + public Viewer getViewer() { + return viewer; + } + @Override public void setFocus() { // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); viewer.getControl().setFocus(); } - private void createActions() { + protected void createActions() { ImageDescriptor fileOpenIcon = PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJ_FOLDER); fileOpenAction = new Action("Open Trace File...", fileOpenIcon) { @Override @@ -138,6 +170,15 @@ changeAvailableAction.setText("Change available of selected trace breakpoint"); changeAvailableAction.setToolTipText("Change available of selected trace breakpoint"); + importBreakpointAction = new Action() { + @Override + public void run() { + debuggingController.importBreakpointAction(); + } + }; + importBreakpointAction.setText("Import Breakpoints"); + importBreakpointAction.setToolTipText("Copy Breakpoints from Eclipse"); + debugAction = new Action() { @Override public void run() { @@ -146,6 +187,8 @@ }; debugAction.setText("Debug"); debugAction.setToolTipText("Debug"); + ImageDescriptor debugImage = DebugUITools.getImageDescriptor(IDebugUIConstants.IMG_ACT_DEBUG); + debugAction.setImageDescriptor(debugImage); terminateAction = new Action() { @Override @@ -155,6 +198,8 @@ }; terminateAction.setText("Terminate"); terminateAction.setToolTipText("Terminate"); + ImageDescriptor terminateImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_TERMINATE); + terminateAction.setImageDescriptor(terminateImage); stepIntoAction = new Action() { @Override @@ -164,6 +209,8 @@ }; stepIntoAction.setText("Step Into"); stepIntoAction.setToolTipText("Step Into"); + ImageDescriptor stepIntoImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_STEP_INTO); + stepIntoAction.setImageDescriptor(stepIntoImage); stepOverAction = new Action() { @Override @@ -173,7 +220,9 @@ }; stepOverAction.setText("Step Over"); stepOverAction.setToolTipText("Step Over"); - + ImageDescriptor stepOverImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_STEP_OVER); + stepOverAction.setImageDescriptor(stepOverImage); + stepReturnAction = new Action() { @Override public void run() { @@ -182,6 +231,17 @@ }; stepReturnAction.setText("Step Return"); stepReturnAction.setToolTipText("Step Return"); + ImageDescriptor stepReturnImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_STEP_RETURN); + stepReturnAction.setImageDescriptor(stepReturnImage); + + stepNextAction = new Action() { + @Override + public void run() { + debuggingController.stepNextAction(); + } + }; + stepNextAction.setText("Step Next"); + stepNextAction.setToolTipText("Step Next"); resumeAction = new Action() { @Override @@ -191,83 +251,34 @@ }; resumeAction.setText("Resume"); resumeAction.setToolTipText("Resume"); - - stepBackIntoAction = new Action() { - @Override - public void run() { - debuggingController.stepBackIntoAction(); - } - }; - stepBackIntoAction.setText("Step Back Into"); - stepBackIntoAction.setToolTipText("Step Back Into"); - - stepBackOverAction = new Action() { - @Override - public void run() { - debuggingController.stepBackOverAction(); - } - }; - stepBackOverAction.setText("Step Back Over"); - stepBackOverAction.setToolTipText("Step Back Over"); - - stepBackReturnAction = new Action() { - @Override - public void run() { - debuggingController.stepBackReturnAction(); - } - }; - stepBackReturnAction.setText("Step Back Return"); - stepBackReturnAction.setToolTipText("Step Back Return"); - - backResumeAction = new Action() { - @Override - public void run() { - debuggingController.backResumeAction(); - } - }; - backResumeAction.setText("Back Resume"); - backResumeAction.setToolTipText("Back Resume"); - - tmpAction = new Action() { - @Override - public void run() { - debuggingController.tmp(); - } - }; - tmpAction.setText("Tmp"); - tmpAction.setToolTipText("Tmp"); + ImageDescriptor image = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_RESUME); + resumeAction.setImageDescriptor(image); } - private void createToolBar() { + protected void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); mgr.add(fileOpenAction); + mgr.add(importBreakpointAction); mgr.add(debugAction); mgr.add(terminateAction); mgr.add(resumeAction); mgr.add(stepIntoAction); mgr.add(stepOverAction); mgr.add(stepReturnAction); - mgr.add(stepBackIntoAction); - mgr.add(stepBackOverAction); - mgr.add(stepBackReturnAction); - mgr.add(backResumeAction); - mgr.add(tmpAction); + mgr.add(stepNextAction); } - private void createMenuBar() { + protected void createMenuBar() { IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); mgr.add(fileOpenAction); + mgr.add(importBreakpointAction); mgr.add(debugAction); mgr.add(terminateAction); mgr.add(resumeAction); mgr.add(stepIntoAction); mgr.add(stepOverAction); mgr.add(stepReturnAction); - mgr.add(stepBackIntoAction); - mgr.add(stepBackOverAction); - mgr.add(stepBackReturnAction); - mgr.add(backResumeAction); - mgr.add(tmpAction); + mgr.add(stepNextAction); } private void createPopupMenu() { @@ -287,8 +298,59 @@ getSite().registerContextMenu(menuMgr, viewer); } - public void update(TraceBreakPoints traceBreakPoints) { - viewer.setInput(traceBreakPoints.getAllTraceBreakPoints()); + public TraceBreakPoints getTraceBreakPoints() { + return traceBreakPoints; + } + +// public void setTraceBreakPoints(TraceBreakPoints traceBreakPoints) { +// this.traceBreakPoints = traceBreakPoints; +// } + + public void reset() { + viewer.setInput(new ArrayList()); viewer.refresh(); } + + public void updateTraceBreakPoints(TraceBreakPoints traceBreakPoints) { + this.traceBreakPoints = traceBreakPoints; + viewer.setInput(traceBreakPoints.getAllTraceBreakPoints()); +// viewer.refresh(); + + final Table table = viewer.getTable(); + for (TableItem item : table.getItems()) { + Object data = item.getData(); + if (data instanceof TraceBreakPoint) { + TraceBreakPoint tbp = (TraceBreakPoint)data; + boolean isAvailable = tbp.isAvailable(); + item.setChecked(isAvailable); + } + } + viewer.refresh(); + } + + public void updateImages(boolean isRunning) { + if (isRunning) { + ImageDescriptor terminateImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_TERMINATE); + terminateAction.setImageDescriptor(terminateImage); + ImageDescriptor stepIntoImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_STEP_INTO); + stepIntoAction.setImageDescriptor(stepIntoImage); + ImageDescriptor stepOverImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_STEP_OVER); + stepOverAction.setImageDescriptor(stepOverImage); + ImageDescriptor stepReturnImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_STEP_RETURN); + stepReturnAction.setImageDescriptor(stepReturnImage); + ImageDescriptor image = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_ELCL_RESUME); + resumeAction.setImageDescriptor(image); + } else { + ImageDescriptor terminateImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_TERMINATE); + terminateAction.setImageDescriptor(terminateImage); + ImageDescriptor stepIntoImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_STEP_INTO); + stepIntoAction.setImageDescriptor(stepIntoImage); + ImageDescriptor stepOverImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_STEP_OVER); + stepOverAction.setImageDescriptor(stepOverImage); + ImageDescriptor stepReturnImage = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_STEP_RETURN); + stepReturnAction.setImageDescriptor(stepReturnImage); + ImageDescriptor image = DebugUITools.getImageDescriptor(IInternalDebugUIConstants.IMG_DLCL_RESUME); + resumeAction.setImageDescriptor(image); + } + } } diff --git a/src/org/ntlab/traceDebugger/BreakPointViewRelatedDelta.java b/src/org/ntlab/traceDebugger/BreakPointViewRelatedDelta.java new file mode 100644 index 0000000..08f1f50 --- /dev/null +++ b/src/org/ntlab/traceDebugger/BreakPointViewRelatedDelta.java @@ -0,0 +1,156 @@ +package org.ntlab.traceDebugger; + +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.IToolBarManager; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.resource.ImageRegistry; +import org.eclipse.swt.widgets.Composite; + +public class BreakPointViewRelatedDelta extends BreakPointView { + private IAction stepBackIntoAction; + private IAction stepBackOverAction; + private IAction stepBackReturnAction; + private IAction backResumeAction; + private DebuggingController debuggingController = DebuggingController.getInstance(); + public static final String ID = "org.ntlab.traceDebugger.breakPointViewRelatedDelta"; + public static final String STEP_BACK_INTO_ELCL = "StepBackInto_ELCL"; + public static final String STEP_BACK_INTO_DLCL = "StepBackInto_DLCL"; + public static final String STEP_BACK_OVER_ELCL = "StepOverInto_ELCL"; + public static final String STEP_BACK_OVER_DLCL = "StepOverInto_DLCL"; + public static final String STEP_BACK_RETURN_ELCL = "StepReturnInto_ELCL"; + public static final String STEP_BACK_RETURN_DLCL = "StepReturnInto_DLCL"; + public static final String BACK_RESUME_ELCL = "BackResume_ELCL"; + public static final String BACK_RESUME_DLCL = "BackResume_DLCL"; + + public BreakPointViewRelatedDelta() { + // TODO Auto-generated constructor stub + System.out.println("BreakPointViewRelatedDelta�N���X���������ꂽ��!"); + } + + @Override + public void createPartControl(Composite parent) { + // TODO Auto-generated method stub + System.out.println("BreakPointViewRelatedDelta#createPartControl(Composite)���Ă΂ꂽ��!"); + super.createPartControl(parent); + TraceDebuggerPlugin.setActiveView(ID, this); + } + + @Override + public void setFocus() { + // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); + viewer.getControl().setFocus(); + } + + @Override + protected void createActions() { + super.createActions(); + ImageRegistry registry = TraceDebuggerPlugin.getDefault().getImageRegistry(); + backResumeAction = new Action() { + @Override + public void run() { + debuggingController.backResumeAction(); + } + }; + backResumeAction.setText("Back Resume"); + backResumeAction.setToolTipText("Back Resume"); + ImageDescriptor backResumeIcon = registry.getDescriptor(BACK_RESUME_DLCL); + backResumeAction.setImageDescriptor(backResumeIcon); + + stepBackIntoAction = new Action() { + @Override + public void run() { + debuggingController.stepBackIntoAction(); + } + }; + stepBackIntoAction.setText("Step Back Into"); + stepBackIntoAction.setToolTipText("Step Back Into"); + ImageDescriptor stepBackIntoIcon = registry.getDescriptor(STEP_BACK_INTO_DLCL); + stepBackIntoAction.setImageDescriptor(stepBackIntoIcon); + + stepBackOverAction = new Action() { + @Override + public void run() { + debuggingController.stepBackOverAction(); + } + }; + stepBackOverAction.setText("Step Back Over"); + stepBackOverAction.setToolTipText("Step Back Over"); + ImageDescriptor stepBackOverIcon = registry.getDescriptor(STEP_BACK_OVER_DLCL); + stepBackOverAction.setImageDescriptor(stepBackOverIcon); + + stepBackReturnAction = new Action() { + @Override + public void run() { + debuggingController.stepBackReturnAction(); + } + }; + stepBackReturnAction.setText("Step Back Return"); + stepBackReturnAction.setToolTipText("Step Back Return"); + ImageDescriptor stepBackReturnIcon = registry.getDescriptor(STEP_BACK_RETURN_DLCL); + stepBackReturnAction.setImageDescriptor(stepBackReturnIcon); + } + + @Override + protected void createToolBar() { + IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); + mgr.add(fileOpenAction); + mgr.add(importBreakpointAction); + mgr.add(debugAction); + mgr.add(stepBackReturnAction); + mgr.add(stepBackOverAction); + mgr.add(stepBackIntoAction); + mgr.add(backResumeAction); + mgr.add(terminateAction); + mgr.add(resumeAction); + mgr.add(stepIntoAction); + mgr.add(stepOverAction); + mgr.add(stepReturnAction); + mgr.add(stepNextAction); + } + + @Override + protected void createMenuBar() { + IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); + mgr.add(fileOpenAction); + mgr.add(importBreakpointAction); + mgr.add(debugAction); + mgr.add(stepBackReturnAction); + mgr.add(stepBackOverAction); + mgr.add(stepBackIntoAction); + mgr.add(backResumeAction); + mgr.add(terminateAction); + mgr.add(resumeAction); + mgr.add(stepIntoAction); + mgr.add(stepOverAction); + mgr.add(stepReturnAction); + mgr.add(stepNextAction); + } + + @Override + public void updateImages(boolean isRunning) { + super.updateImages(isRunning); + ImageRegistry registry = TraceDebuggerPlugin.getDefault().getImageRegistry(); + if (isRunning) { + ImageDescriptor stepBackIntoImage = registry.getDescriptor(STEP_BACK_INTO_ELCL); + stepBackIntoAction.setImageDescriptor(stepBackIntoImage); + ImageDescriptor stepBackOverImage = registry.getDescriptor(STEP_BACK_OVER_ELCL); + stepBackOverAction.setImageDescriptor(stepBackOverImage); + ImageDescriptor stepBackReturnImage = registry.getDescriptor(STEP_BACK_RETURN_ELCL); + stepBackReturnAction.setImageDescriptor(stepBackReturnImage); + ImageDescriptor backResumeImage = registry.getDescriptor(BACK_RESUME_ELCL); + backResumeAction.setImageDescriptor(backResumeImage); + } else { + ImageDescriptor stepBackIntoImage = registry.getDescriptor(STEP_BACK_INTO_DLCL); + stepBackIntoAction.setImageDescriptor(stepBackIntoImage); + ImageDescriptor stepBackOverImage = registry.getDescriptor(STEP_BACK_OVER_DLCL); + stepBackOverAction.setImageDescriptor(stepBackOverImage); + ImageDescriptor stepBackReturnImage = registry.getDescriptor(STEP_BACK_RETURN_DLCL); + stepBackReturnAction.setImageDescriptor(stepBackReturnImage); + ImageDescriptor backResumeImage = registry.getDescriptor(BACK_RESUME_DLCL); + backResumeAction.setImageDescriptor(backResumeImage); + } + } +} diff --git a/src/org/ntlab/traceDebugger/CallStackLabelProvider.java b/src/org/ntlab/traceDebugger/CallStackLabelProvider.java index aa467e8..c38fd4c 100644 --- a/src/org/ntlab/traceDebugger/CallStackLabelProvider.java +++ b/src/org/ntlab/traceDebugger/CallStackLabelProvider.java @@ -1,13 +1,16 @@ 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 +39,23 @@ } 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 CallStackModel) { + CallStackModel callStackModel = (CallStackModel)value; + if (callStackModel.isHighlighting()) { + return DeltaMarkerLabelProvider.COORDINATOR_LABEL_COLOR; + } + } + } + return null; + } } diff --git a/src/org/ntlab/traceDebugger/CallStackModel.java b/src/org/ntlab/traceDebugger/CallStackModel.java index dd056a2..5fbc854 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; @@ -37,7 +38,13 @@ String declaringType = Trace.getDeclaringType(signature, isConstructor); declaringType = declaringType.substring(declaringType.lastIndexOf(".") + 1); String methodName = Trace.getMethodName(signature); - String args = "(" + signature.split("\\(")[1]; + String args = "("; + String delimiter = ""; + String[] argArray = signature.split("\\(")[1].split(","); + for (String arg : argArray) { + args += (delimiter + arg.substring(arg.lastIndexOf(".") + 1)); + delimiter = ", "; + } StringBuilder sb = new StringBuilder(); sb.append(objectType); @@ -47,5 +54,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..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; @@ -20,6 +21,10 @@ public List getDebuggingThreadCallStacks() { return debuggingThreadCallStacks; } + + public Map> getAllCallStacks() { + return allCallStacks; + } public TreeNode[] getAllCallStacksTree() { if (allCallStacks.isEmpty()) return new TreeNode[1]; @@ -99,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 a55bd45..6064419 100644 --- a/src/org/ntlab/traceDebugger/CallStackView.java +++ b/src/org/ntlab/traceDebugger/CallStackView.java @@ -1,7 +1,9 @@ package org.ntlab.traceDebugger; -import org.eclipse.jface.action.Action; -import org.eclipse.jface.action.IAction; +import java.util.List; +import java.util.Map; + +import org.eclipse.core.resources.IMarker; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.IToolBarManager; import org.eclipse.jface.viewers.ISelectionChangedListener; @@ -11,19 +13,17 @@ import org.eclipse.jface.viewers.TreeNodeContentProvider; import org.eclipse.jface.viewers.TreeViewer; import org.eclipse.swt.widgets.Composite; -import org.eclipse.ui.ISharedImages; -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.AbstractAnalyzer; +import org.ntlab.traceDebugger.analyzerProvider.DeltaExtractionAnalyzer; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; public class CallStackView extends ViewPart { - private TreeViewer viewer; - private IAction refreshAction; - private CallStackModels callStackModels = new CallStackModels(); + protected TreeViewer viewer; + protected CallStackModel selectionCallStackModel; + protected CallStackModels callStackModels = new CallStackModels(); public static final String ID = "org.ntlab.traceDebugger.callStackView"; public CallStackView() { @@ -50,10 +50,10 @@ Object value = ((TreeNode)element).getValue(); if (value instanceof CallStackModel) { CallStackModel callStackModel = (CallStackModel)value; + selectionCallStackModel = callStackModel; MethodExecution methodExecution = callStackModel.getMethodExecution(); - TracePoint tp = callStackModel.getTracePoint(); JavaEditorOperator.openSrcFileOfMethodExecution(methodExecution, callStackModel.getCallLineNo()); - ((VariableView)getOtherView(VariableView.ID)).updateVariablesByTracePoint(tp, false); + additonalActionOnSelectionChanged(callStackModel); } } } @@ -61,38 +61,44 @@ createActions(); createToolBar(); createMenuBar(); + createPopupMenu(); + TraceDebuggerPlugin.setActiveView(ID, this); } @Override public void setFocus() { // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); viewer.getControl().setFocus(); } - private void createActions() { - refreshAction = new Action() { - @Override - public void run() { - refresh(); - } - }; - refreshAction.setText("refresh"); - refreshAction.setToolTipText("refresh"); - refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_ELCL_SYNCED)); + protected void createActions() { + } - private void createToolBar() { + protected void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); - mgr.add(refreshAction); } - private void createMenuBar() { + protected void createMenuBar() { IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); - mgr.add(refreshAction); + } + + protected void createPopupMenu() { + + } + + protected void additonalActionOnSelectionChanged(CallStackModel selectedCallStackModel) { + TracePoint tp = selectedCallStackModel.getTracePoint(); + TracePoint debuggingTp = DebuggingController.getInstance().getCurrentTp(); + VariableView variableView = (VariableView)TraceDebuggerPlugin.getActiveView(VariableView.ID); + variableView.updateVariablesByTracePoint(tp, false, debuggingTp); } public void updateByTracePoint(TracePoint tp) { callStackModels.updateByTracePoint(tp); + refresh(); + selectionCallStackModel = null; } public void refresh() { @@ -108,17 +114,30 @@ public void reset() { callStackModels.reset(); -// viewer.setInput(null); -// viewer.expandAll(); refresh(); } - private IViewPart getOtherView(String viewId) { - IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); - try { - return workbenchPage.showView(viewId); - } catch (PartInitException e) { - throw new RuntimeException(e); - } + public CallStackModel getSelectionCallStackModel() { + return selectionCallStackModel; } + + public boolean isSelectionOnTop() { + if (selectionCallStackModel == null) return false; + TreeNode[] nodes = callStackModels.getAllCallStacksTree(); + if (nodes == null || nodes[0] == null) return false; + TreeNode[] children = nodes[0].getChildren(); + Object obj = children[0].getValue(); + if (!(obj instanceof CallStackModel)) return false; + CallStackModel topCallStackModel = (CallStackModel)obj; + return topCallStackModel.equals(selectionCallStackModel); + } + + public Map> getCallStackModels() { + return callStackModels.getAllCallStacks(); + } + + public void highlight(MethodExecution methodExecution) { + callStackModels.highlight(methodExecution); + viewer.refresh(); + } } diff --git a/src/org/ntlab/traceDebugger/CallStackViewRelatedDelta.java b/src/org/ntlab/traceDebugger/CallStackViewRelatedDelta.java new file mode 100644 index 0000000..c97c4ff --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallStackViewRelatedDelta.java @@ -0,0 +1,110 @@ +package org.ntlab.traceDebugger; + +import java.util.List; +import java.util.Map; + +import org.eclipse.core.resources.IMarker; +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.action.IMenuListener; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.MenuManager; +import org.eclipse.jface.action.Separator; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Menu; +import org.eclipse.ui.IWorkbenchActionConstants; +import org.eclipse.ui.IWorkbenchPage; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; + +public class CallStackViewRelatedDelta extends CallStackView { + private IAction deltaAction; + public static final String ID = "org.ntlab.traceDebugger.callStackViewRelatedDelta"; + + public CallStackViewRelatedDelta() { + // TODO Auto-generated constructor stub + System.out.println("callStackViewRelatedDelta�N���X���������ꂽ��"); + } + + @Override + public void createPartControl(Composite parent) { + // TODO Auto-generated method stub + System.out.println("CallStackViewRelatedDelta#createPartControl(Composite)���Ă΂ꂽ��!"); + super.createPartControl(parent); + TraceDebuggerPlugin.setActiveView(ID, this); + } + + @Override + public void setFocus() { + // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); + viewer.getControl().setFocus(); + } + + @Override + protected void createActions() { + deltaAction = new Action() { + @Override + public void run() { + if (selectionCallStackModel != null) { + MethodExecution callee = selectionCallStackModel.getMethodExecution(); + MethodExecution caller = callee.getParent(); + String callerClassName = caller.getThisClassName(); + String callerId = caller.getThisObjId(); + String calleeClassName = callee.getThisClassName(); + String calleeId = callee.getThisObjId(); + TracePoint before = callee.getCallerTracePoint(); + DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.createNewView(DeltaMarkerView.ID, IWorkbenchPage.VIEW_ACTIVATE); + newDeltaMarkerView.extractDeltaForThisToAnother(callerId, callerClassName, calleeId, calleeClassName, before); + } + } + }; + deltaAction.setText("Extract Delta"); + deltaAction.setToolTipText("Extract Delta"); + } + + protected void createPopupMenu() { + MenuManager menuMgr = new MenuManager("#PopupMenu"); + menuMgr.setRemoveAllWhenShown(true); + menuMgr.addMenuListener(new IMenuListener() { + @Override + public void menuAboutToShow(IMenuManager manager) { + if (selectionCallStackModel != null) { + MethodExecution callee = selectionCallStackModel.getMethodExecution(); + MethodExecution caller = callee.getParent(); + String callerId = caller.getThisObjId(); + String callerClassName = caller.getThisClassName(); + callerClassName = callerClassName.substring(callerClassName.lastIndexOf(".") + 1); + String calleeId = callee.getThisObjId(); + String calleeClassName = callee.getThisClassName(); + calleeClassName = calleeClassName.substring(calleeClassName.lastIndexOf(".") + 1); + String text = String.format("Extract Delta (%s: %s �� %s: %s)", callerId, callerClassName, calleeId, calleeClassName); + deltaAction.setText(text); + deltaAction.setToolTipText(text); + manager.add(deltaAction); + manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); + } + } + }); + Menu menu = menuMgr.createContextMenu(viewer.getControl()); + viewer.getControl().setMenu(menu); + getSite().registerContextMenu(menuMgr, viewer); + } + + @Override + protected void additonalActionOnSelectionChanged(CallStackModel selectedCallStackModel) { + super.additonalActionOnSelectionChanged(selectedCallStackModel); + DeltaMarkerView deltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.getActiveView(DeltaMarkerView.ID); + if (deltaMarkerView != null) { + DeltaMarkerManager deltaMarkerManager = deltaMarkerView.getDeltaMarkerManager(); + if (deltaMarkerManager != null) { + Map> deltaMarkers = deltaMarkerManager.getMarkers(); + if (deltaMarkers != null) { + VariableViewRelatedDelta variableView = (VariableViewRelatedDelta)TraceDebuggerPlugin.getActiveView(VariableViewRelatedDelta.ID); + variableView.markAndExpandVariablesByDeltaMarkers(deltaMarkers); + } + } + } + } +} diff --git a/src/org/ntlab/traceDebugger/CallTreeLabelProvider.java b/src/org/ntlab/traceDebugger/CallTreeLabelProvider.java new file mode 100644 index 0000000..371e09e --- /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(), 198, 219, 174); + } + } + } + return null; + } +} diff --git a/src/org/ntlab/traceDebugger/CallTreeModel.java b/src/org/ntlab/traceDebugger/CallTreeModel.java new file mode 100644 index 0000000..21278d3 --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallTreeModel.java @@ -0,0 +1,86 @@ +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; + private CallTreeModel parent; + private List children = new ArrayList<>(); + + 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 = "("; + String delimiter = ""; + String[] argArray = signature.split("\\(")[1].split(","); + for (String arg : argArray) { + args += (delimiter + arg.substring(arg.lastIndexOf(".") + 1)); + delimiter = ", "; + } + + 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; +// } + + public CallTreeModel getParent() { + return parent; + } + + public List getChildren() { + return children; + } + + public void setParent(CallTreeModel parent) { + this.parent = parent; + } + + public void addChildren(CallTreeModel child) { + this.children.add(child); + } +} diff --git a/src/org/ntlab/traceDebugger/CallTreeModels.java b/src/org/ntlab/traceDebugger/CallTreeModels.java new file mode 100644 index 0000000..c61903d --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallTreeModels.java @@ -0,0 +1,86 @@ +package org.ntlab.traceDebugger; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.eclipse.core.resources.IMarker; +import org.eclipse.jface.viewers.TreeNode; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; + +public class CallTreeModels { + private TreeNode[] roots; + private List callTreeModelList = new ArrayList<>(); + private Map callTreeModelsMemo = new HashMap<>(); + + public TreeNode[] getCallTreeModels() { + return roots; + } + + public List getCallTreeModelList() { + return callTreeModelList; + } + + public void reset() { + roots = new TreeNode[1]; + callTreeModelList.clear(); + callTreeModelsMemo.clear(); + } + + public void update(DeltaMarkerManager deltaMarkerManager) { + reset(); + IMarker coordinatorMarker = deltaMarkerManager.getCoordinatorDeltaMarker(); + if (coordinatorMarker != null) { + MethodExecution coordinatorME = DeltaMarkerManager.getMethodExecution(coordinatorMarker); + List markersOrderByAdding = deltaMarkerManager.getMarkersByOrder(); + for (IMarker marker : markersOrderByAdding) { + MethodExecution me = DeltaMarkerManager.getMethodExecution(marker); + CallTreeModel callTreeModel = new CallTreeModel(me); + if (!(callTreeModelsMemo.containsKey(me))) { + callTreeModelsMemo.put(me, callTreeModel); + if (!(me.equals(coordinatorME))) { + linkTreeToCoordinator(callTreeModel, coordinatorME); + } + } + } + createCallTreeModels(callTreeModelsMemo.get(coordinatorME)); + } + } + + private void linkTreeToCoordinator(CallTreeModel currentModel, final MethodExecution coordinatorME) { + MethodExecution currentME = currentModel.getMethodExecution(); + MethodExecution parentME = currentME.getParent(); + if (parentME == null) return; + CallTreeModel parentModel = callTreeModelsMemo.get(parentME); + boolean isNewParentModel = (parentModel == null); + if (isNewParentModel) { + parentModel = new CallTreeModel(parentME); + callTreeModelsMemo.put(parentME, parentModel); + } + currentModel.setParent(parentModel); + parentModel.addChildren(currentModel); + if (isNewParentModel && !(parentME.equals(coordinatorME))) { + linkTreeToCoordinator(parentModel, coordinatorME); + } + } + + private void createCallTreeModels(CallTreeModel coordinator) { + roots = new TreeNode[1]; + callTreeModelList.clear(); + createCallTreeModels(roots, 0, coordinator, null); + } + + private void createCallTreeModels(TreeNode[] nodes, int index, CallTreeModel callTreeModel, TreeNode parent) { + callTreeModelList.add(callTreeModel); + nodes[index] = new TreeNode(callTreeModel); + nodes[index].setParent(parent); + List children = callTreeModel.getChildren(); + TreeNode[] childNodes = new TreeNode[children.size()]; + nodes[index].setChildren(childNodes); + for (int i = 0; i < childNodes.length; i++) { + CallTreeModel child = children.get(i); + createCallTreeModels(childNodes, i, child, nodes[index]); + } + } +} diff --git a/src/org/ntlab/traceDebugger/CallTreeView.java b/src/org/ntlab/traceDebugger/CallTreeView.java new file mode 100644 index 0000000..73e8f94 --- /dev/null +++ b/src/org/ntlab/traceDebugger/CallTreeView.java @@ -0,0 +1,120 @@ +package org.ntlab.traceDebugger; + +import java.util.List; + +import org.eclipse.core.resources.IMarker; +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.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.DeltaExtractionAnalyzer; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; + +public class CallTreeView extends ViewPart { + private TreeViewer viewer; + private CallTreeModels callTreeModels = new CallTreeModels(); + 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)) return; + Object value = ((TreeNode)element).getValue(); + if (!(value instanceof CallTreeModel)) return; + CallTreeModel callTreeModel = (CallTreeModel)value; + MethodExecution methodExecution = callTreeModel.getMethodExecution(); + TracePoint tp = methodExecution.getEntryPoint(); + + if ((DebuggingController.getInstance().isRunning())) { + highlight(methodExecution); + DebuggingController controller = DebuggingController.getInstance(); + controller.jumpToTheTracePoint(tp, false); + CallStackViewRelatedDelta callStackView = (CallStackViewRelatedDelta)TraceDebuggerPlugin.getActiveView(CallStackViewRelatedDelta.ID); + VariableViewRelatedDelta variableView = ((VariableViewRelatedDelta)TraceDebuggerPlugin.getActiveView(VariableViewRelatedDelta.ID)); + DeltaMarkerView deltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.getActiveView(DeltaMarkerView.ID); + DeltaMarkerManager deltaMarkerManager = deltaMarkerView.getDeltaMarkerManager(); + IMarker coodinatorMarker = deltaMarkerManager.getCoordinatorDeltaMarker(); + MethodExecution coordinatorME = DeltaMarkerManager.getMethodExecution(coodinatorMarker); + if (coordinatorME != null) callStackView.highlight((MethodExecution)coordinatorME); + variableView.markAndExpandVariablesByDeltaMarkers(deltaMarkerManager.getMarkers()); + } else { + int lineNo = tp.getStatement().getLineNo(); + JavaEditorOperator.openSrcFileOfMethodExecution(methodExecution, lineNo); + } + } + }); + createActions(); + createToolBar(); + createMenuBar(); + TraceDebuggerPlugin.setActiveView(ID, this); + } + + @Override + public void setFocus() { + // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); + viewer.getControl().setFocus(); + } + + private void createActions() { + + } + + private void createToolBar() { + IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); + } + + private void createMenuBar() { + IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); + } + + public void update(DeltaMarkerManager deltaMarkerManager) { + callTreeModels.update(deltaMarkerManager); + 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() { + callTreeModels.reset(); + viewer.setInput(callTreeModels.getCallTreeModelList()); + viewer.refresh(); + } +} diff --git a/src/org/ntlab/traceDebugger/DebuggingController.java b/src/org/ntlab/traceDebugger/DebuggingController.java index 5c0ce48..19f6b6f 100644 --- a/src/org/ntlab/traceDebugger/DebuggingController.java +++ b/src/org/ntlab/traceDebugger/DebuggingController.java @@ -1,25 +1,59 @@ package org.ntlab.traceDebugger; -import org.eclipse.debug.core.model.IBreakpoint; +import java.util.HashMap; +import java.util.Map; +import org.eclipse.core.filebuffers.FileBuffers; +import org.eclipse.core.filebuffers.ITextFileBuffer; +import org.eclipse.core.filebuffers.ITextFileBufferManager; +import org.eclipse.core.filebuffers.LocationKind; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.jobs.Job; import org.eclipse.jface.dialogs.InputDialog; import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.text.BadLocationException; +import org.eclipse.jface.text.IDocument; +import org.eclipse.jface.text.IRegion; import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.FileDialog; import org.eclipse.swt.widgets.Shell; -import org.eclipse.ui.IViewPart; -import org.eclipse.ui.IWorkbenchPage; -import org.eclipse.ui.PartInitException; -import org.eclipse.ui.PlatformUI; +import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayUpdate; +import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldUpdate; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; import org.ntlab.traceDebugger.analyzerProvider.DeltaExtractionAnalyzer; -import org.ntlab.traceDebugger.analyzerProvider.ReferencePoint; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; +import org.ntlab.traceDebugger.analyzerProvider.VariableUpdatePointFinder; public class DebuggingController { + private static final DebuggingController theInstance = new DebuggingController(); private TracePoint debuggingTp; private TraceBreakPoint selectedTraceBreakPoint; - private TraceBreakPoints traceBreakPoints = new TraceBreakPoints(); +// private TraceBreakPoints traceBreakPoints; + private IMarker currentLineMarker; + private LoadingTraceFileStatus loadingTraceFileStatus = LoadingTraceFileStatus.NOT_YET; + private boolean isRunning = false; + public static final String CURRENT_MARKER_ID = "org.ntlab.traceDebugger.currentMarker"; + + private enum LoadingTraceFileStatus { + NOT_YET, PROGRESS, DONE + } + + private DebuggingController() { + + } + + public static DebuggingController getInstance() { + return theInstance; + } public void setDebuggingTp(TracePoint tp) { this.debuggingTp = tp; @@ -29,96 +63,165 @@ this.selectedTraceBreakPoint = tbp; } + public TracePoint getCurrentTp() { + return debuggingTp.duplicate(); + } + + public boolean isRunning() { + return isRunning; + } + public boolean fileOpenAction(Shell shell) { + if (loadingTraceFileStatus == LoadingTraceFileStatus.PROGRESS) { + MessageDialog.openInformation(null, "Loading", "This debugger is loading the trace."); + return false; + } + if (isRunning) { + MessageDialog.openInformation(null, "Running", "This debugger is running on the trace."); + return false; + } FileDialog fileDialog = new FileDialog(shell, SWT.OPEN); fileDialog.setText("Open Trace File"); fileDialog.setFilterExtensions(new String[]{"*.*"}); String path = fileDialog.open(); if (path == null) return false; - TraceDebuggerPlugin.setAnalyzer(new DeltaExtractionAnalyzer(new TraceJSON(path))); - traceBreakPoints.clear(); - ((CallStackView)getOtherView(CallStackView.ID)).reset(); - ((VariableView)getOtherView(VariableView.ID)).reset(); - ((BreakPointView)getOtherView(BreakPointView.ID)).update(traceBreakPoints); + + ((CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID)).reset(); + ((VariableView)TraceDebuggerPlugin.getActiveView(VariableView.ID)).reset(); + ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).reset(); + ((TracePointsView)TraceDebuggerPlugin.getActiveView(TracePointsView.ID)).reset(); + CallTreeView callTreeView = (CallTreeView)TraceDebuggerPlugin.getActiveView(CallTreeView.ID); + if (callTreeView != null) callTreeView.reset(); + loadTraceFileOnOtherThread(path); return true; } + private void loadTraceFileOnOtherThread(final String filePath) { + Job job = new Job("Loading Trace File") { + @Override + protected IStatus run(IProgressMonitor monitor) { + monitor.beginTask("Loading Trace File" + " (" + filePath + ")", IProgressMonitor.UNKNOWN); + loadingTraceFileStatus = LoadingTraceFileStatus.PROGRESS; + TraceDebuggerPlugin.setAnalyzer(null); + TraceJSON trace = new TraceJSON(filePath); + TraceDebuggerPlugin.setAnalyzer(new DeltaExtractionAnalyzer(trace)); + VariableUpdatePointFinder.getInstance().setTrace(trace); + final TraceBreakPoints traceBreakPoints = new TraceBreakPoints(trace); + + // GUI�̑����GUI�̃C�x���g�f�B�X�p�b�`���s���Ă���X���b�h���炵������ł��Ȃ��̂ł������� + final BreakPointView breakpointView = (BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID); + Control control = breakpointView.getViewer().getControl(); + control.getDisplay().syncExec(new Runnable() { + @Override + public void run() { + breakpointView.updateTraceBreakPoints(traceBreakPoints); + } + }); + monitor.done(); + if (!(monitor.isCanceled())) { + loadingTraceFileStatus = LoadingTraceFileStatus.DONE; + return Status.OK_STATUS; + } else { + loadingTraceFileStatus = LoadingTraceFileStatus.NOT_YET; + return Status.CANCEL_STATUS; + } + } + }; + job.setUser(true); + job.schedule(); + } + public boolean addTraceBreakPointAction() { - if (TraceDebuggerPlugin.getAnalyzer() == null) { + if (loadingTraceFileStatus != LoadingTraceFileStatus.DONE) { MessageDialog.openInformation(null, "Error", "Trace file was not found"); return false; } -// InputDialog inputDialog = new InputDialog(null, "method signature dialog", "Input method signature", "void Company.pay(Money,Person)", null); -// InputDialog inputDialog = new InputDialog(null, "method signature dialog", "Input method signature", "void worstCase.P.setM(worstCase.M)", null); - InputDialog inputDialog = new InputDialog(null, "method signature dialog", "Input method signature", "public void org.jhotdraw.draw.DefaultDrawingView.addToSelection(org.jhotdraw.draw.Figure)", null); + InputDialog inputDialog = new InputDialog(null, "method signature dialog", "Input method signature", "", null); if (inputDialog.open() != InputDialog.OK) return false; String methodSignature = inputDialog.getValue(); inputDialog = new InputDialog(null, "line No dialog", "Input line no", "", null); if (inputDialog.open() != InputDialog.OK) return false; int lineNo = Integer.parseInt(inputDialog.getValue()); - long currentTime = 0L; - if (debuggingTp != null) { - currentTime = debuggingTp.getStatement().getTimeStamp(); - } - boolean isSuccess = traceBreakPoints.addTraceBreakPoint(methodSignature, lineNo, currentTime); + TraceBreakPoints traceBreakPoints = ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).getTraceBreakPoints(); + boolean isSuccess = traceBreakPoints.addTraceBreakPoint(methodSignature, lineNo); if (!isSuccess) { MessageDialog.openInformation(null, "Error", "This trace point does not exist in the trace."); return false; } - ((BreakPointView)getOtherView(BreakPointView.ID)).update(traceBreakPoints); + ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).updateTraceBreakPoints(traceBreakPoints); + return true; + } + + public boolean importBreakpointAction() { + if (loadingTraceFileStatus != LoadingTraceFileStatus.DONE) { + MessageDialog.openInformation(null, "Error", "Trace file was not found"); + return false; + } + TraceBreakPoints traceBreakPoints = ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).getTraceBreakPoints(); + traceBreakPoints.importBreakpointFromEclipse(); + ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).updateTraceBreakPoints(traceBreakPoints); return true; } public boolean removeTraceBreakPointAction() { if (selectedTraceBreakPoint == null) return false; + TraceBreakPoints traceBreakPoints = ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).getTraceBreakPoints(); traceBreakPoints.removeTraceBreakPoint(selectedTraceBreakPoint); - ((BreakPointView)getOtherView(BreakPointView.ID)).update(traceBreakPoints); + ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).updateTraceBreakPoints(traceBreakPoints); return true; } public boolean changeAvailableAction() { if (selectedTraceBreakPoint == null) return false; selectedTraceBreakPoint.changeAvailable(); - ((BreakPointView)getOtherView(BreakPointView.ID)).update(traceBreakPoints); + TraceBreakPoints traceBreakPoints = ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).getTraceBreakPoints(); + ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).updateTraceBreakPoints(traceBreakPoints); return true; } -// public boolean debugAction() { -// if (TraceDebuggerPlugin.getAnalyzer() == null) { -// MessageDialog.openInformation(null, "Error", "Trace file was not found"); -// return false; -// } -// terminateAction(); -// traceBreakPoints.resetAll(); -// debuggingTp = traceBreakPoints.getNextTracePoint(0L); -// if (debuggingTp == null) return false; -// refresh(false); -// return true; -// } - public boolean debugAction() { - if (TraceDebuggerPlugin.getAnalyzer() == null) { + if (loadingTraceFileStatus != LoadingTraceFileStatus.DONE) { MessageDialog.openInformation(null, "Error", "Trace file was not found"); return false; } - terminateAction(); -// traceBreakPoints.resetAll(); - traceBreakPoints.reset(); -// debuggingTp = traceBreakPoints.getNextTracePoint(0L); + if (isRunning) { + return false; + } + TraceBreakPoints traceBreakPoints = ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).getTraceBreakPoints(); debuggingTp = traceBreakPoints.getFirstTracePoint(); - if (debuggingTp == null) return false; - refresh(false); + if (debuggingTp == null) { + MessageDialog.openInformation(null, "Error", "An available breakpoint was not found"); + return false; + } + refresh(null, debuggingTp, false); + ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).updateImages(true); + isRunning = true; return true; } public void terminateAction() { debuggingTp = null; - ((CallStackView)getOtherView(CallStackView.ID)).reset(); - ((VariableView)getOtherView(VariableView.ID)).reset(); + if (currentLineMarker != null) { + try { + currentLineMarker.delete(); + } catch (CoreException e) { + e.printStackTrace(); + } + } + ((CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID)).reset(); + ((VariableView)TraceDebuggerPlugin.getActiveView(VariableView.ID)).reset(); + ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).updateImages(false); + isRunning = false; } public boolean stepIntoAction() { + if (!isRunning) return false; if (debuggingTp == null) return false; + TracePoint callStackTp = getTracePointSelectedOnCallStack(); + if (callStackTp != null && !(callStackTp.equals(debuggingTp))) { + debuggingTp = callStackTp; + } + TracePoint previousTp = debuggingTp; debuggingTp = debuggingTp.duplicate(); debuggingTp.stepFull(); if (!debuggingTp.isValid()) { @@ -126,31 +229,60 @@ MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; } -// traceBreakPoints.forwardAll(debuggingTp.getStatement().getTimeStamp()); - refresh(false); + refresh(null, debuggingTp, false); return true; } public boolean stepOverAction() { + if (!isRunning) return false; if (debuggingTp == null) return false; + TracePoint callStackTp = getTracePointSelectedOnCallStack(); + if (callStackTp != null && !(callStackTp.equals(debuggingTp))) { + debuggingTp = callStackTp; + } + TracePoint previousTp = debuggingTp; debuggingTp = debuggingTp.duplicate(); int currentLineNo = debuggingTp.getStatement().getLineNo(); - boolean isReturned; + boolean isReturned = false; + + // �X�e�b�v�I�[�o�[��p���ē��B�_�����‚��Ă��� + TracePoint startTp = debuggingTp.duplicate(); while (!(isReturned = !(debuggingTp.stepOver()))) { if (currentLineNo != debuggingTp.getStatement().getLineNo()) break; + previousTp = debuggingTp.duplicate(); } + TracePoint goalTp = debuggingTp.duplicate(); + if (!isReturned) { + // �X�e�b�v�t����p���č��x�͌Ăяo����ɂ�����Ȃ���\�ߌ��‚��Ă��������B�_�܂Ői�܂��� (�ϐ������X�V�̂��ߓr���̃A�b�v�f�[�g��S�ďE��) + debuggingTp = startTp; + do { + Statement statement = debuggingTp.getStatement(); + if (statement.equals(goalTp.getStatement())) break; + if (statement instanceof FieldUpdate || statement instanceof ArrayUpdate) { + Variables.getInstance().addDifferentialUpdatePoint(debuggingTp); + } + } while (debuggingTp.stepFull()); + } else { + debuggingTp = goalTp; + } + if (!debuggingTp.isValid()) { terminateAction(); MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; - } -// traceBreakPoints.forwardAll(debuggingTp.getStatement().getTimeStamp()); - refresh(isReturned); + } + refresh(previousTp, debuggingTp, isReturned, true); return true; } public boolean stepReturnAction() { + if (!isRunning) return false; if (debuggingTp == null) return false; + TracePoint callStackTp = getTracePointSelectedOnCallStack(); + if (callStackTp != null && !(callStackTp.equals(debuggingTp))) { + debuggingTp = callStackTp; + } + TracePoint previousTp = debuggingTp; debuggingTp = debuggingTp.duplicate(); while (debuggingTp.stepOver()); if (!debuggingTp.isValid()) { @@ -158,27 +290,70 @@ MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; } -// traceBreakPoints.forwardAll(debuggingTp.getStatement().getTimeStamp()); - refresh(true); + refresh(previousTp, debuggingTp, true); return true; } + public boolean stepNextAction() { + if (!isRunning) return false; + if (debuggingTp == null) return false; + TracePoint callStackTp = getTracePointSelectedOnCallStack(); + if (callStackTp != null && !(callStackTp.equals(debuggingTp))) { + debuggingTp = callStackTp; + } + TracePoint previousTp = debuggingTp; + debuggingTp = debuggingTp.duplicate(); + TracePoint startTp = debuggingTp.duplicate(); + boolean isReturned = !(debuggingTp.stepNext()); + TracePoint goalTp = debuggingTp.duplicate(); + if (!isReturned) { + // �X�e�b�v�t����p���č��x�͌Ăяo����ɂ�����Ȃ���\�ߌ��‚��Ă��������B�_�܂Ői�܂��� (�ϐ������X�V�̂��ߓr���̃A�b�v�f�[�g��S�ďE��) + debuggingTp = startTp; + do { + Statement statement = debuggingTp.getStatement(); + if (statement.equals(goalTp.getStatement())) break; + if (statement instanceof FieldUpdate || statement instanceof ArrayUpdate) { + Variables.getInstance().addDifferentialUpdatePoint(debuggingTp); + } + } while (debuggingTp.stepFull()); + } else { + debuggingTp = startTp; + startTp.stepOver(); + } + + if (!debuggingTp.isValid()) { + terminateAction(); + MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); + return false; + } + refresh(previousTp, debuggingTp, isReturned, true); + return true; + } + public boolean resumeAction() { + if (!isRunning) return false; if (debuggingTp == null) return false; long currentTime = debuggingTp.getStatement().getTimeStamp(); + TracePoint previousTp = debuggingTp; + TraceBreakPoints traceBreakPoints = ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).getTraceBreakPoints(); debuggingTp = traceBreakPoints.getNextTracePoint(currentTime); if (debuggingTp == null) { terminateAction(); MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; } -// traceBreakPoints.forwardAll(debuggingTp.getStatement().getTimeStamp()); - refresh(false); + refresh(null, debuggingTp, false); return true; } public boolean stepBackIntoAction() { + if (!isRunning) return false; if (debuggingTp == null) return false; + TracePoint callStackTp = getTracePointSelectedOnCallStack(); + if (callStackTp != null && !(callStackTp.equals(debuggingTp))) { + debuggingTp = callStackTp; + } + TracePoint previousTp = debuggingTp; debuggingTp = debuggingTp.duplicate(); debuggingTp.stepBackFull(); if (!debuggingTp.isValid()) { @@ -186,13 +361,18 @@ MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; } -// traceBreakPoints.reverseAll(debuggingTp.getStatement().getTimeStamp()); - refresh(true); + refresh(null, debuggingTp, true); return true; } public boolean stepBackOverAction() { + if (!isRunning) return false; if (debuggingTp == null) return false; + TracePoint callStackTp = getTracePointSelectedOnCallStack(); + if (callStackTp != null && !(callStackTp.equals(debuggingTp))) { + debuggingTp = callStackTp; + } + TracePoint previousTp = debuggingTp; debuggingTp = debuggingTp.duplicate(); int currentLineNo = debuggingTp.getStatement().getLineNo(); boolean isReturned; @@ -204,13 +384,18 @@ MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; } -// traceBreakPoints.reverseAll(debuggingTp.getStatement().getTimeStamp()); - refresh(!isReturned); + refresh(null, debuggingTp, !isReturned); return true; } public boolean stepBackReturnAction() { + if (!isRunning) return false; if (debuggingTp == null) return false; + TracePoint callStackTp = getTracePointSelectedOnCallStack(); + if (callStackTp != null && !(callStackTp.equals(debuggingTp))) { + debuggingTp = callStackTp; + } + TracePoint previousTp = debuggingTp; debuggingTp = debuggingTp.duplicate(); while (debuggingTp.stepBackOver()); if (!debuggingTp.isValid()) { @@ -218,61 +403,112 @@ MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; } -// traceBreakPoints.reverseAll(debuggingTp.getStatement().getTimeStamp()); - refresh(false); + refresh(null, debuggingTp, false); return true; } public boolean backResumeAction() { - if (debuggingTp == null) return false; + if (!isRunning) return false; + if (debuggingTp == null) return false; + TracePoint previousTp = debuggingTp; long currentTime = debuggingTp.getStatement().getTimeStamp(); + TraceBreakPoints traceBreakPoints = ((BreakPointView)TraceDebuggerPlugin.getActiveView(BreakPointView.ID)).getTraceBreakPoints(); debuggingTp = traceBreakPoints.getPreviousTracePoint(currentTime); if (debuggingTp == null) { terminateAction(); MessageDialog.openInformation(null, "Terminate", "This trace is terminated"); return false; } -// traceBreakPoints.reverseAll(debuggingTp.getStatement().getTimeStamp()); - refresh(false); + refresh(null, debuggingTp, false); return true; } - - /** - * ���݂̃f�o�b�O�ʒu�𒊏o�����f���^�̒�ӂ̃g���[�X�|�C���g�ɍ��킹�� (�Ƃ肠�����m�F���邾���p) - * @return - */ - public boolean tmp() { - DeltaExtractionAnalyzer analyzer = (DeltaExtractionAnalyzer)TraceDebuggerPlugin.getAnalyzer(); - ReferencePoint rp = analyzer.getBottomPoint(); - long previousTime = debuggingTp.getStatement().getTimeStamp(); - long rpTime = rp.getTime(); - debuggingTp = rp.getTracePoint(); -// if (rpTime < previousTime) { -// traceBreakPoints.reverseAll(rpTime); -// } else { -// traceBreakPoints.forwardAll(rpTime); -// } - refresh(false); - return true; - } - - private void refresh(boolean isReturned) { - MethodExecution me = debuggingTp.getMethodExecution(); - int lineNo = debuggingTp.getStatement().getLineNo(); - JavaEditorOperator.openSrcFileOfMethodExecution(me, lineNo); - CallStackView callStackView = ((CallStackView)getOtherView(CallStackView.ID)); - callStackView.updateByTracePoint(debuggingTp); - callStackView.refresh(); - ((VariableView)getOtherView(VariableView.ID)).updateVariablesByTracePoint(debuggingTp, isReturned); - ((BreakPointView)getOtherView(BreakPointView.ID)).update(traceBreakPoints); - } - private IViewPart getOtherView(String viewId) { - IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); - try { - return workbenchPage.showView(viewId); - } catch (PartInitException e) { - throw new RuntimeException(e); + /** + * ���݂̃f�o�b�O�ʒu���w�肵���g���[�X�|�C���g�ɍ��킹�� + * @return + */ + public boolean jumpToTheTracePoint(TracePoint tp, boolean isReturned) { + if (!isRunning) return false; + if (tp == null) return false; + TracePoint previousTp = debuggingTp; + debuggingTp = tp.duplicate(); + refresh(null, debuggingTp, isReturned); + return true; + } + + private void refresh(TracePoint from, TracePoint to, boolean isReturned) { + refresh(from, to, isReturned, false); + } + + private void refresh(TracePoint from, TracePoint to, boolean isReturned, boolean canDifferentialUpdateVariables) { + MethodExecution me = to.getMethodExecution(); + int lineNo = to.getStatement().getLineNo(); + IMarker marker = createCurrentLineMarker(me, lineNo); + JavaEditorOperator.markAndOpenJavaFile(marker); + CallStackView callStackView = ((CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID)); + callStackView.updateByTracePoint(to); + VariableView variableView = ((VariableView)TraceDebuggerPlugin.getActiveView(VariableView.ID)); + if (!isReturned && canDifferentialUpdateVariables) { +// variableView.updateVariablesByTracePoint(from, to, isReturned); + variableView.updateVariablesForDifferential(from, to, isReturned); + } else { + variableView.updateVariablesByTracePoint(from, to, isReturned); } + if (TraceDebuggerPlugin.getActiveView(DeltaMarkerView.ID) != null) { + refreshRelatedDelta(to); + } + } + + private void refreshRelatedDelta(TracePoint tp) { + DeltaMarkerView deltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.getActiveView(DeltaMarkerView.ID); + if (deltaMarkerView == null) return; + DeltaMarkerManager deltaMarkerManager = deltaMarkerView.getDeltaMarkerManager(); + if (deltaMarkerManager == null) return; + IMarker coordinatorMarker = deltaMarkerManager.getCoordinatorDeltaMarker(); + if (coordinatorMarker == null) return; + MethodExecution coordinatorME = DeltaMarkerManager.getMethodExecution(coordinatorMarker); + CallStackView callStackView = (CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID); + callStackView.highlight(coordinatorME); + CallTreeView callTreeView = (CallTreeView)TraceDebuggerPlugin.getActiveView(CallTreeView.ID); + callTreeView.highlight(tp.getMethodExecution()); + VariableViewRelatedDelta variableView = (VariableViewRelatedDelta)TraceDebuggerPlugin.getActiveView(VariableViewRelatedDelta.ID); + variableView.markAndExpandVariablesByDeltaMarkers(deltaMarkerManager.getMarkers()); + } + + public IMarker createCurrentLineMarker(MethodExecution methodExecution, int highlightLineNo) { + IFile file = JavaElementFinder.findIFile(methodExecution); + try { + if (currentLineMarker != null) currentLineMarker.delete(); + currentLineMarker = file.createMarker(CURRENT_MARKER_ID); + Map attributes = new HashMap<>(); + attributes.put(IMarker.TRANSIENT, true); + attributes.put(IMarker.LINE_NUMBER, highlightLineNo); + + IPath path = file.getFullPath(); + ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager(); + manager.connect(path, LocationKind.IFILE, null); + ITextFileBuffer buffer = manager.getTextFileBuffer(path, LocationKind.IFILE); + IDocument document = buffer.getDocument(); + try { + IRegion region = document.getLineInformation(highlightLineNo - 1); + attributes.put(IMarker.CHAR_START, region.getOffset()); + attributes.put(IMarker.CHAR_END, region.getOffset() + region.getLength()); + } catch (BadLocationException e) { + e.printStackTrace(); + } + currentLineMarker.setAttributes(attributes); + } catch (CoreException e) { + e.printStackTrace(); + } + return currentLineMarker; + } + + private TracePoint getTracePointSelectedOnCallStack() { + CallStackView callStackView = (CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID); + CallStackModel callStackModel = callStackView.getSelectionCallStackModel(); + if (callStackModel != null) { + return callStackModel.getTracePoint(); + } + return null; } } diff --git a/src/org/ntlab/traceDebugger/DeltaMarkerLabelProvider.java b/src/org/ntlab/traceDebugger/DeltaMarkerLabelProvider.java new file mode 100644 index 0000000..ce8d510 --- /dev/null +++ b/src/org/ntlab/traceDebugger/DeltaMarkerLabelProvider.java @@ -0,0 +1,132 @@ +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.graphics.Color; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Display; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; + +public class DeltaMarkerLabelProvider extends LabelProvider implements ITableLabelProvider, ITableColorProvider { + public static final Color COORDINATOR_LABEL_COLOR = new Color(Display.getDefault(), 255, 255, 153); + public static final Color SETTER_SIDE_LABEL_COLOR = new Color(Display.getDefault(), 255, 204, 216); + public static final Color GETTER_SIDE_LABEL_COLOR = new Color(Display.getDefault(), 153, 255, 255); + public static final Color BOTTOM_LABEL_COLOR = new Color(Display.getDefault(), 255, 204, 153); + + @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(DeltaMarkerManager.DELTA_MARKER_ATR_OBJECT_ID); + return (objectId != null) ? objectId.toString() : null; + case 2: + Object objectType = marker.getAttribute(DeltaMarkerManager.DELTA_MARKER_ATR_OBJECT_TYPE); + if (objectType == null) return null; + StringBuilder simpleObjectTypeName = new StringBuilder(); + String[] simpleNames = objectType.toString().split(" -> "); + simpleObjectTypeName.append(simpleNames[0].substring(simpleNames[0].lastIndexOf(".") + 1)); + if (simpleNames.length == 2) { + simpleObjectTypeName.append(" -> "); + simpleObjectTypeName.append(simpleNames[1].substring(simpleNames[1].lastIndexOf(".") + 1)); + } + return simpleObjectTypeName.toString(); + case 3: + Object obj = marker.getAttribute(DeltaMarkerManager.DELTA_MARKER_ATR_ALIAS_TYPE); + if (obj == null) return null; + // note: �X�l�[�N�P�[�X���p�X�J���P�[�X(�������P��Ԃ��󔒂ŋ�؂�)�ɕς��� + String aliasType = obj.toString(); + aliasType = aliasType.toLowerCase().replace("_", " "); + StringBuilder sb = new StringBuilder(); + for (int index = -1;;) { + sb.append(aliasType.substring(index + 1, index + 2).toUpperCase()); + int nextIndex = aliasType.indexOf(" ", index + 1); + if (nextIndex == -1) { + sb.append(aliasType.substring(index + 2)); + break; + } else { + sb.append(aliasType.substring(index + 2, nextIndex + 1)); + index = nextIndex; + } + } + aliasType = sb.toString(); + return aliasType; + case 4: + String resource = marker.getResource().toString(); + return resource.substring(resource.lastIndexOf("/") + 1); + case 5: + return "" + marker.getAttribute(IMarker.LINE_NUMBER); + } + } 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("RelatedPoint")) { + return BOTTOM_LABEL_COLOR; + } else if (str.contains("Coordinator")) { + return COORDINATOR_LABEL_COLOR; + } else if (str.contains("Src")) { + return SETTER_SIDE_LABEL_COLOR; + } else if (str.contains("Dst")) { + return GETTER_SIDE_LABEL_COLOR; + } + return null; + } + if (value instanceof IMarker) { + IMarker marker = (IMarker)value; + try { + String markerType = marker.getType(); + if (markerType.equals(DeltaMarkerManager.BOTTOM_DELTA_MARKER)) { + return BOTTOM_LABEL_COLOR; + } else if (markerType.equals(DeltaMarkerManager.COORDINATOR_DELTA_MARKER)) { + return COORDINATOR_LABEL_COLOR; + } else if (markerType.equals(DeltaMarkerManager.SRC_SIDE_DELTA_MARKER)) { + return SETTER_SIDE_LABEL_COLOR; + } else if (markerType.equals(DeltaMarkerManager.DST_SIDE_DELTA_MARKER)) { + return GETTER_SIDE_LABEL_COLOR; + } + } catch (CoreException e) { + e.printStackTrace(); + } + } + } + return null; + } +} diff --git a/src/org/ntlab/traceDebugger/DeltaMarkerView.java b/src/org/ntlab/traceDebugger/DeltaMarkerView.java new file mode 100644 index 0000000..55311ce --- /dev/null +++ b/src/org/ntlab/traceDebugger/DeltaMarkerView.java @@ -0,0 +1,235 @@ +package org.ntlab.traceDebugger; + +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.IWorkbenchPage; +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.AbstractAnalyzer; +import org.ntlab.traceDebugger.analyzerProvider.Alias; +import org.ntlab.traceDebugger.analyzerProvider.Alias.AliasType; +import org.ntlab.traceDebugger.analyzerProvider.DeltaExtractionAnalyzer; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; + +public class DeltaMarkerView extends ViewPart { + private TreeViewer viewer; + private Shell shell; + private IMarker selectionMarker; + private boolean doNotUpdateCallTreeView; + private DeltaMarkerManager deltaMarkerManager; + public static String ID = "org.ntlab.traceDebugger.deltaMarkerView"; + + @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", "Type", "Alias", "Source", "Line"}; + int[] tableColumnWidth = {120, 100, 120, 120, 100, 80}; + 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; + selectionMarker = (IMarker)value; + updateOtherViewsByMarker(selectionMarker); + doNotUpdateCallTreeView = true; + viewer.getControl().setFocus(); + } + }); + viewer.refresh(); + + createActions(); + createToolBar(); + createMenuBar(); + createPopupMenu(); + TraceDebuggerPlugin.setActiveView(ID, this); + } + + 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 setFocus() { + // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); + if (!doNotUpdateCallTreeView) { + CallTreeView callTreeView = (CallTreeView)TraceDebuggerPlugin.getActiveView(CallTreeView.ID); + callTreeView.update(deltaMarkerManager); +// updateOtherViewsByMarker(selectionMarker); + } + doNotUpdateCallTreeView = false; + viewer.getControl().setFocus(); + } + + public DeltaMarkerManager getDeltaMarkerManager() { + return deltaMarkerManager; + } + + public TracePoint getCreationPoint() { + IMarker creationPointMarker = deltaMarkerManager.getBottomDeltaMarker(); + return DeltaMarkerManager.getTracePoint(creationPointMarker); + } + + public TracePoint getCoordinatorPoint() { + IMarker coordinatorMarker = deltaMarkerManager.getCoordinatorDeltaMarker(); + return DeltaMarkerManager.getTracePoint(coordinatorMarker); + } + + @Override + public void dispose() { + deltaMarkerManager.clearAllMarkers(); + CallTreeView callTreeView = ((CallTreeView)TraceDebuggerPlugin.getActiveView(CallTreeView.ID)); + callTreeView.reset(); + super.dispose(); + } + + private void updateOtherViewsByMarker(IMarker marker) { + DebuggingController controller = DebuggingController.getInstance(); + IMarker coordinator = deltaMarkerManager.getCoordinatorDeltaMarker(); + TracePoint coordinatorPoint = DeltaMarkerManager.getTracePoint(coordinator); + if (marker != null) { + try { + Object obj = marker.getAttribute(DeltaMarkerManager.DELTA_MARKER_ATR_DATA); + TracePoint jumpPoint; + boolean isReturned = false; + if (obj instanceof Alias) { + Alias alias = (Alias)obj; + jumpPoint = alias.getOccurrencePoint(); + Alias.AliasType type = alias.getAliasType(); + isReturned = type.equals(AliasType.METHOD_INVOCATION) || type.equals(AliasType.CONSTRACTOR_INVOCATION); + } else if (obj instanceof TracePoint) { + jumpPoint = (TracePoint)obj; + } else { + jumpPoint = coordinatorPoint; + } + controller.jumpToTheTracePoint(jumpPoint, isReturned); + IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); + IDE.openEditor(page, marker); + CallStackView callStackView = (CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID); + callStackView.highlight(coordinatorPoint.getMethodExecution()); + VariableViewRelatedDelta variableView = (VariableViewRelatedDelta)TraceDebuggerPlugin.getActiveView(VariableViewRelatedDelta.ID); + variableView.markAndExpandVariablesByDeltaMarkers(deltaMarkerManager.getMarkers()); + } catch (CoreException e) { + e.printStackTrace(); + } + } + } + + public void extractDeltaForContainerToComponent(Variable variable) { + AbstractAnalyzer analyzer = TraceDebuggerPlugin.getAnalyzer(); + if (analyzer instanceof DeltaExtractionAnalyzer) { + DeltaExtractionAnalyzer deltaAnalyzer = (DeltaExtractionAnalyzer)analyzer; + deltaMarkerManager = deltaAnalyzer.extractDeltaForContainerToComponent(variable); + deltaMarkerManager.createMarkerAndOpenJavaFileForAll(); // �f���^���o�̌��ʂ����Ƀ\�[�X�R�[�h�𔽓]�\������ + updateAfterExtractingDelta(); + } + } + + public void extractDeltaForThisToAnother(String thisId, String thisClassName, String anotherId, String anotherClassName, TracePoint before) { + AbstractAnalyzer analyzer = TraceDebuggerPlugin.getAnalyzer(); + if (analyzer instanceof DeltaExtractionAnalyzer) { + DeltaExtractionAnalyzer deltaAnalyzer = (DeltaExtractionAnalyzer)analyzer; + deltaMarkerManager = deltaAnalyzer.extractDeltaForThisToAnother(thisId, thisClassName, anotherId, anotherClassName, before); + deltaMarkerManager.createMarkerAndOpenJavaFileForAll(); // �f���^���o�̌��ʂ����Ƀ\�[�X�R�[�h�𔽓]�\������ + updateAfterExtractingDelta(); + } + } + + private void updateAfterExtractingDelta() { + viewer.setInput(deltaMarkerManager.getMarkerTreeNodes()); + viewer.expandAll(); + viewer.refresh(); + TracePoint coordinatorPoint = getCoordinatorPoint(); + TracePoint creationPoint = getCreationPoint(); + MethodExecution coordinatorME = coordinatorPoint.getMethodExecution(); + MethodExecution bottomME = creationPoint.getMethodExecution(); + DebuggingController controller = DebuggingController.getInstance(); + controller.jumpToTheTracePoint(creationPoint, false); + VariableViewRelatedDelta variableView = (VariableViewRelatedDelta)(TraceDebuggerPlugin.getActiveView(VariableViewRelatedDelta.ID)); + variableView.markAndExpandVariablesByDeltaMarkers(deltaMarkerManager.getMarkers()); + CallStackView callStackView = (CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID); + callStackView.highlight(coordinatorME); + CallTreeView callTreeView = (CallTreeView)TraceDebuggerPlugin.getActiveView(CallTreeView.ID); + callTreeView.update(deltaMarkerManager); + callTreeView.highlight(bottomME); + TracePointsView tracePointsView = (TracePointsView)TraceDebuggerPlugin.getActiveView(TracePointsView.ID); + tracePointsView.addTracePoint(creationPoint); + } + +// public void extractDelta(Variable variable, boolean isContainerToComponent) { +// AbstractAnalyzer analyzer = TraceDebuggerPlugin.getAnalyzer(); +// if (analyzer instanceof DeltaExtractionAnalyzer) { +// DeltaExtractionAnalyzer deltaAnalyzer = (DeltaExtractionAnalyzer)analyzer; +// if (isContainerToComponent) { +// deltaMarkerManager = deltaAnalyzer.extractDeltaForContainerToComponent(variable); +// } else { +// deltaMarkerManager = deltaAnalyzer.extractDeltaForThisToAnother(variable); +// } +// deltaMarkerManager.createMarkerAndOpenJavaFileForAll(); // �f���^���o�̌��ʂ����Ƀ\�[�X�R�[�h�𔽓]�\������ +// update(); +// +// TracePoint coordinatorPoint = getCoordinatorPoint(); +// TracePoint creationPoint = getCreationPoint(); +// MethodExecution coordinatorME = coordinatorPoint.getMethodExecution(); +// MethodExecution bottomME = creationPoint.getMethodExecution(); +// DebuggingController controller = DebuggingController.getInstance(); +// controller.jumpToTheTracePoint(creationPoint, false); +// VariableViewRelatedDelta variableView = (VariableViewRelatedDelta)(TraceDebuggerPlugin.getActiveView(VariableViewRelatedDelta.ID)); +// variableView.markAndExpandVariablesByDeltaMarkers(deltaMarkerManager.getMarkers()); +// CallStackView callStackView = (CallStackView)TraceDebuggerPlugin.getActiveView(CallStackView.ID); +// callStackView.highlight(coordinatorME); +// CallTreeView callTreeView = (CallTreeView)TraceDebuggerPlugin.getActiveView(CallTreeView.ID); +// callTreeView.update(deltaMarkerManager); +// callTreeView.highlight(bottomME); +// TracePointsView tracePointsView = (TracePointsView)TraceDebuggerPlugin.getActiveView(TracePointsView.ID); +// tracePointsView.addTracePoint(creationPoint); +// } +// } +} diff --git a/src/org/ntlab/traceDebugger/JavaEditorOperator.java b/src/org/ntlab/traceDebugger/JavaEditorOperator.java index 0e5ade2..a12b4cd 100644 --- a/src/org/ntlab/traceDebugger/JavaEditorOperator.java +++ b/src/org/ntlab/traceDebugger/JavaEditorOperator.java @@ -1,59 +1,25 @@ package org.ntlab.traceDebugger; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IMarker; -import org.eclipse.core.resources.IProject; -import org.eclipse.core.resources.IResource; -import org.eclipse.core.resources.IWorkspaceRoot; -import org.eclipse.core.resources.ResourcesPlugin; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IPath; -import org.eclipse.core.runtime.Path; -import org.eclipse.debug.core.DebugPlugin; -import org.eclipse.debug.core.IBreakpointManager; -import org.eclipse.debug.core.model.IBreakpoint; -import org.eclipse.debug.core.model.ILineBreakpoint; import org.eclipse.jdt.core.IJavaElement; -import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IType; -import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; -import org.eclipse.jdt.core.Signature; import org.eclipse.jdt.ui.JavaUI; import org.eclipse.jface.text.BadLocationException; import org.eclipse.jface.text.IDocument; -import org.eclipse.jface.text.IRegion; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.IWorkbench; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchWindow; 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.eclipse.ui.texteditor.IDocumentProvider; import org.eclipse.ui.texteditor.ITextEditor; -import org.ntlab.traceAnalysisPlatform.tracer.trace.ClassInfo; import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; -import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; -import org.ntlab.traceDebugger.analyzerProvider.Alias; public class JavaEditorOperator { - private static List markers = new ArrayList<>(); - - public static void openSrcFileOfAlias(Alias alias) { - MethodExecution methodExecution = alias.getMethodExecution(); - int lineNo = alias.getLineNo(); - openSrcFileOfMethodExecution(methodExecution, lineNo); - } /** * �����œn����meCaller���ɂ���methodExecution����`����Ă���N���X�̃\�[�X�R�[�h��Ώ�Eclipse�̃G�f�B�^�ŊJ������ @@ -61,23 +27,13 @@ * @param methodExecution */ public static void openSrcFileOfMethodExecution(MethodExecution methodExecution, int highlightLineNo) { - IType type = findIType(methodExecution); + IType type = JavaElementFinder.findIType(methodExecution); if (type != null) { - IMethod method = findIMethod(methodExecution, type); + IMethod method = JavaElementFinder.findIMethod(methodExecution, type); openSrcFile(type, method); highlightCurrentJavaFile(highlightLineNo); } } - - /** - * �����œn����IType��IMethod�ɑΉ�����\�[�X�R�[�h��Ώ�Eclipse�̃G�f�B�^�ŊJ������ - * - * @param type - * @param method - */ - private static void openSrcFile(IType type, IMethod method) { - openInJavaEditor(type, method); - } /** * ���݃G�f�B�^�ŊJ����Ă���t�@�C���̎w�肵���s�Ƀn�C���C�g�������� @@ -94,158 +50,31 @@ IDocument document = provider.getDocument(editor.getEditorInput()); try { editor.selectAndReveal(document.getLineOffset(lineNo - 1), document.getLineLength(lineNo - 1)); -// tmp(); } catch (BadLocationException e) { e.printStackTrace(); } } } - public static void markAndOpenJavaFile(MethodExecution methodExecution, int lineNo, String message, String markerId) { - IFile file = findIFile(methodExecution); + public static void markAndOpenJavaFile(IMarker marker) { + IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); try { - FileEditorInput input = new FileEditorInput(file); - FileDocumentProvider provider = new FileDocumentProvider(); - provider.connect(input); - IDocument document = provider.getDocument(input); - IMarker marker = file.createMarker(markerId); - Map attributes = new HashMap<>(); - attributes.put(IMarker.MESSAGE, message); - attributes.put(IMarker.TRANSIENT, true); - if (lineNo > 1) { - IRegion r = document.getLineInformation(lineNo - 1); - attributes.put(IMarker.LINE_NUMBER, lineNo); - attributes.put(IMarker.CHAR_START, r.getOffset()); - attributes.put(IMarker.CHAR_END, r.getOffset() + r.getLength()); - } - marker.setAttributes(attributes); - markers.add(marker); - IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); IDE.openEditor(page, marker); - } catch (CoreException | BadLocationException e) { + } catch (PartInitException e) { e.printStackTrace(); } } - -// private static void tmp() { -// IBreakpointManager mgr = DebugPlugin.getDefault().getBreakpointManager(); -// IBreakpoint[] bps = mgr.getBreakpoints(); -// for (IBreakpoint bp : bps) { -// IMarker marker = bp.getMarker(); -// int lineNo = marker.getAttribute(IMarker.LINE_NUMBER, -1); -// String name = marker.getAttribute("org.eclipse.jdt.debug.core.typeName", ""); -//// TraceJSON trace = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); -//// ClassInfo classInfo = trace.getClassInfo(name); -//// if (classInfo == null) continue; -// -// -//// name = mgr.getTypeName(bp); -// try { -// for (Map.Entry entry: marker.getAttributes().entrySet()) { -// System.out.println(entry.getKey() + ": " + entry.getValue()); -// } -// } catch (CoreException e) { -// e.printStackTrace(); -// } -// System.out.println("Name: " + name + ", lineNo: " + lineNo); -// } -// } - - public static IFile findIFile(MethodExecution methodExecution) { - TraceJSON trace = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); - String declaringClassName = methodExecution.getDeclaringClassName(); - declaringClassName = declaringClassName.replace(".", ""); - String tmp = trace.getClassInfo(declaringClassName).getPath(); - IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects(); - String projectName = ""; - for (IProject project : projects) { - projectName = project.getFullPath().toString(); - if (tmp.contains(projectName + "/")) break; - } - tmp = tmp.replace(tmp.substring(0, tmp.lastIndexOf(projectName)), ""); - tmp = tmp.replace("/bin/", "/src/"); - tmp = tmp.replace(".class", ".java"); - String filePath = tmp; - IPath path = new Path(filePath); - return ResourcesPlugin.getWorkspace().getRoot().getFile(path); - } - public static void deleteMarkers(String markerId) { - Iterator it = markers.iterator(); - while (it.hasNext()) { - IMarker marker = it.next(); - try { - if (marker.getType().equals(markerId)) { - marker.delete(); - it.remove(); - } - } catch (CoreException e) { - e.printStackTrace(); - } - } - } - - public static IType findIType(MethodExecution methodExecution) { - String declaringClassName = methodExecution.getDeclaringClassName(); - declaringClassName = declaringClassName.replace(".", ""); - return findIType(methodExecution, declaringClassName); + /** + * �����œn����IType��IMethod�ɑΉ�����\�[�X�R�[�h��Ώ�Eclipse�̃G�f�B�^�ŊJ������ + * + * @param type + * @param method + */ + private static void openSrcFile(IType type, IMethod method) { + openInJavaEditor(type, method); } - public static IType findIType(MethodExecution methodExecution, String declaringClassName) { - String projectPath = getLoaderPath(methodExecution, declaringClassName); - IType type = null; - if (projectPath != null) { - IJavaProject javaProject = findJavaProject(projectPath); - if (javaProject != null) { - try { - type = javaProject.findType(declaringClassName); - } catch (JavaModelException e) { - e.printStackTrace(); - } - } - } - return type; - } - - private static String getLoaderPath(MethodExecution methodExecution, String declaringClassName) { - TraceJSON traceJSON = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); - ClassInfo classInfo = traceJSON.getClassInfo(declaringClassName); - if (classInfo == null && methodExecution != null) { - declaringClassName = methodExecution.getThisClassName(); - classInfo = traceJSON.getClassInfo(declaringClassName); - } - String loaderPath = null; - if (classInfo != null) { - // �Ȃ���loaderPath���擾�ł��Ă��Ȃ����߁A���ۂɏo�͂����JSON�g���[�X���Q�l�ɂ���path����^���Ă݂� - String path = classInfo.getPath(); - String declaringClassNameString = declaringClassName.replace(".", "/"); - loaderPath = path.substring(0, path.lastIndexOf(declaringClassNameString)); // path����N���X�̊��S���薼�ȍ~��S�ĊO�������̂�projectPath�ɂ��Ă݂� - } - return loaderPath; - } - - private static IJavaProject findJavaProject(String projectPath) { - IJavaProject javaProject = null; - IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); - IProject[] projects = root.getProjects(); - for (IProject project : projects) { - if (checkProjectPath(project, projectPath)) { - javaProject = JavaCore.create(project); - break; - } - } - return javaProject; - } - - private static boolean checkProjectPath(IProject project, String projectPath) { - String projectLocation = project.getLocation().toString(); - if (projectPath.startsWith(projectLocation)) { - String[] projectPathSplit = projectPath.split(projectLocation); - return (projectPathSplit[1].charAt(0) == '/'); // �v���W�F�N�g���̑O����v�ɂ�鑼�v���W�F�N�g�Ƃ̌딻�������� - } - return false; - } - private static void openInJavaEditor(IType type, IMethod method) { try { if (type != null) { @@ -262,75 +91,4 @@ e.printStackTrace(); } } - - private static IMethod findIMethod(MethodExecution methodExecution, IType type) { - IMethod method = null; - if (type != null) { - String methodSignature = methodExecution.getSignature(); - method = findIMethod(type, methodSignature); - } - return method; - } - - public static IMethod findIMethod(IType type, String methodSignature) { - try { - for (IMethod method : type.getMethods()) { - if (checkMethodSignature(type, method, methodSignature)) { - return method; - } - } - } catch (JavaModelException e) { - e.printStackTrace(); - } - return null; - } - - private static boolean checkMethodSignature(IType type, IMethod method, String methodSignature) { - String fqcn = type.getFullyQualifiedName(); - try { - StringBuilder jdtMethodSignature = new StringBuilder(); - jdtMethodSignature.append((method.isConstructor()) ? (fqcn + "(") : (fqcn + "." + method.getElementName() + "(")); - if (methodSignature.contains(jdtMethodSignature)) { - // ������v���Ă����ꍇ�Ɍ���A�������X�g����������ł���v���邩�ǂ����𔻒� (�I�[�o�[���[�h�ɂ��딻��������) - jdtMethodSignature.append(String.join(",", parseFQCNParameters(type, method)) + ")"); // �S�����̃V�O�l�`�������S����N���X���ɕϊ�����,�ŋ�؂��������� - return methodSignature.contains(jdtMethodSignature); - } - } catch (JavaModelException e) { - e.printStackTrace(); - } - return false; - } - - /** - * IMethod����擾�ł���S�����̃V�O�l�`�������S����N���X���ɒu�������Ċi�[�������X�g��Ԃ� - * - * @param type - * @param method - * @return - */ - private static List parseFQCNParameters(IType type, IMethod method) throws JavaModelException { - List parameters = new ArrayList<>(); - for (String parameterType : method.getParameterTypes()) { - String readableType = Signature.toString(parameterType); // �V�O�l�`���̕�������^���̕�����ɕϊ� (�z��͌���[]���‚�) - String[] readableTypeSplit = { "", "" }; // �^����[]�̕����p - int firstBracketIndex = readableType.indexOf("[]"); - final int NO_BRACKET_INDEX = -1; - if (firstBracketIndex == NO_BRACKET_INDEX) { - readableTypeSplit[0] = readableType; // �^�� - } else { - readableTypeSplit[0] = readableType.substring(0, firstBracketIndex); // �^�� - readableTypeSplit[1] = readableType.substring(firstBracketIndex); // �^���̌���[]�S�� - } - String[][] resolveType = type.resolveType(readableTypeSplit[0]); // �p�b�P�[�W���ƃN���X���̑g�ݍ��킹���擾 - if (resolveType != null) { - if (resolveType[0][0].isEmpty()) { - readableTypeSplit[0] = (resolveType[0][1]); // �f�t�H���g�p�b�P�[�W�̏ꍇ�̓p�b�P�[�W����.�͓���Ȃ� - } else { - readableTypeSplit[0] = (resolveType[0][0] + "." + resolveType[0][1]); // ���S����N���X�� - } - } - parameters.add(readableTypeSplit[0] + readableTypeSplit[1]); - } - return parameters; - } } diff --git a/src/org/ntlab/traceDebugger/JavaElementFinder.java b/src/org/ntlab/traceDebugger/JavaElementFinder.java new file mode 100644 index 0000000..7617bf7 --- /dev/null +++ b/src/org/ntlab/traceDebugger/JavaElementFinder.java @@ -0,0 +1,222 @@ +package org.ntlab.traceDebugger; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IWorkspace; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.Path; +import org.eclipse.jdt.core.IClasspathEntry; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.IMethod; +import org.eclipse.jdt.core.IType; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jdt.core.JavaModelException; +import org.eclipse.jdt.core.Signature; +import org.ntlab.traceAnalysisPlatform.tracer.trace.ClassInfo; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; + +public class JavaElementFinder { + + public static IFile findIFile(MethodExecution methodExecution) { + TraceJSON trace = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); + String declaringClassName = methodExecution.getDeclaringClassName(); + declaringClassName = declaringClassName.replace(".", ""); + ClassInfo info = trace.getClassInfo(declaringClassName); + if (info == null) { + // �����N���X�̏ꍇ�͂��̊O�̃N���X����ClassInfo���擾���� (Java�̃\�[�X�t�@�C�����擾���邽��) + StringBuilder tmp = new StringBuilder(); + tmp.append(declaringClassName.substring(0, declaringClassName.lastIndexOf("."))); + info = trace.getClassInfo(tmp.toString()); + } + if (info == null) return null; + + String tmp = info.getPath(); + IWorkspace workspace = ResourcesPlugin.getWorkspace(); + IProject[] projects = workspace.getRoot().getProjects(); + String projectName = ""; + String srcForderName = "/src"; + boolean hasFoundSrcForderName = false; + for (IProject project : projects) { + projectName = project.getFullPath().toString(); + if (!(tmp.contains(projectName + "/"))) continue; + IJavaProject javaProject = JavaCore.create(project); + try { + for (IClasspathEntry entry : javaProject.getResolvedClasspath(true)) { + if (entry.getEntryKind() != IClasspathEntry.CPE_SOURCE) continue; + IPath srcForderPath = entry.getPath(); + srcForderName = srcForderPath.toString(); + hasFoundSrcForderName = true; + break; + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + if (hasFoundSrcForderName) break; + } +// tmp = tmp.replace(tmp.substring(0, tmp.lastIndexOf(projectName)), ""); + tmp = tmp.replace(tmp.substring(0, tmp.indexOf(projectName)), ""); + tmp = tmp.replace("/bin", srcForderName.substring(srcForderName.lastIndexOf("/"))); + tmp = tmp.replace(".class", ".java"); + String filePath = tmp; + IPath path = new Path(filePath); + return ResourcesPlugin.getWorkspace().getRoot().getFile(path); + } + + public static IType findIType(MethodExecution methodExecution) { + String declaringClassName = methodExecution.getDeclaringClassName(); + declaringClassName = declaringClassName.replace(".", ""); + return findIType(methodExecution, declaringClassName); + } + + public static IType findIType(MethodExecution methodExecution, String declaringClassName) { + String projectPath = getLoaderPath(methodExecution, declaringClassName); +// if (projectPath == null) projectPath = previousJavaProjectPath; + if (projectPath != null) { + IJavaProject javaProject = findJavaProject(projectPath); + if (javaProject != null) { +// previousJavaProjectPath = projectPath; + try { + return javaProject.findType(declaringClassName); + } catch (JavaModelException e) { + e.printStackTrace(); + } + } + } + return null; + } + + private static String getLoaderPath(MethodExecution methodExecution, String declaringClassName) { + TraceJSON traceJSON = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); + ClassInfo classInfo = traceJSON.getClassInfo(declaringClassName); + if (classInfo == null && methodExecution != null) { + declaringClassName = methodExecution.getThisClassName(); + classInfo = traceJSON.getClassInfo(declaringClassName); + } + String loaderPath = null; + if (classInfo != null) { + // �Ȃ���loaderPath���擾�ł��Ă��Ȃ����߁A���ۂɏo�͂����JSON�g���[�X���Q�l�ɂ���path����^���Ă݂� + String path = classInfo.getPath(); + String declaringClassNameString = declaringClassName.replace(".", "/"); + loaderPath = path.substring(0, path.lastIndexOf(declaringClassNameString)); // path����N���X�̊��S���薼�ȍ~��S�ĊO�������̂�projectPath�ɂ��Ă݂� + } + return loaderPath; + } + + private static IJavaProject findJavaProject(String projectPath) { + IJavaProject javaProject = null; + IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); + IProject[] projects = root.getProjects(); + for (IProject project : projects) { + if (checkProjectPath(project, projectPath)) { + javaProject = JavaCore.create(project); + break; + } + } + return javaProject; + } + + private static boolean checkProjectPath(IProject project, String projectPath) { + String projectLocation = project.getLocation().toString(); +// if (projectPath.startsWith(projectLocation)) { +// String[] projectPathSplit = projectPath.split(projectLocation); +// return (projectPathSplit[1].charAt(0) == '/'); // �v���W�F�N�g���̑O����v�ɂ�鑼�v���W�F�N�g�Ƃ̌딻�������� +// } + if (projectPath.startsWith(projectLocation)) { + String[] projectPathSplit = projectPath.split(projectLocation); + return (projectPathSplit[1].charAt(0) == '/'); // �v���W�F�N�g���̑O����v�ɂ�鑼�v���W�F�N�g�Ƃ̌딻�������� + } else if (projectPath.startsWith(projectLocation.substring(1))) { + String[] projectPathSplit = projectPath.split(projectLocation.substring(1)); + return (projectPathSplit[1].charAt(0) == '/'); // �v���W�F�N�g���̑O����v�ɂ�鑼�v���W�F�N�g�Ƃ̌딻�������� + } + return false; + } + + public static IMethod findIMethod(MethodExecution methodExecution, IType type) { + IMethod method = null; + if (type != null) { + String methodSignature = methodExecution.getSignature(); + method = findIMethod(type, methodSignature); + } + return method; + } + + public static IMethod findIMethod(IType type, String methodSignature) { + try { + for (IMethod method : type.getMethods()) { + if (checkMethodSignature(type, method, methodSignature)) { + return method; + } + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + return null; + } + + private static boolean checkMethodSignature(IType type, IMethod method, String methodSignature) { + String fqcn = type.getFullyQualifiedName(); + try { + StringBuilder jdtMethodSignature = new StringBuilder(); + jdtMethodSignature.append((method.isConstructor()) ? (fqcn + "(") : (fqcn + "." + method.getElementName() + "(")); + if (methodSignature.contains(jdtMethodSignature)) { + // ������v���Ă����ꍇ�Ɍ���A�������X�g����������ł���v���邩�ǂ����𔻒� (�I�[�o�[���[�h�ɂ��딻��������) + jdtMethodSignature.append(String.join(",", parseFQCNParameters(type, method)) + ")"); // �S�����̃V�O�l�`�������S����N���X���ɕϊ�����,�ŋ�؂��������� + return methodSignature.contains(jdtMethodSignature); + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + return false; + } + + public static String resolveType(IType type, String typeName) { + try { + String[][] resolveTypes = type.resolveType(typeName); + if (resolveTypes != null) { + if (resolveTypes[0][0].isEmpty()) { + return (resolveTypes[0][1]); // �f�t�H���g�p�b�P�[�W�̏ꍇ�̓p�b�P�[�W����.�͓���Ȃ� + } else { + return (resolveTypes[0][0] + "." + resolveTypes[0][1]); // ���S����N���X�� + } + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + return null; + } + + /** + * IMethod����擾�ł���S�����̃V�O�l�`�������S����N���X���ɒu�������Ċi�[�������X�g��Ԃ� + * + * @param type + * @param method + * @return + */ + private static List parseFQCNParameters(IType type, IMethod method) throws JavaModelException { + List parameters = new ArrayList<>(); + for (String parameterType : method.getParameterTypes()) { + String readableType = Signature.toString(parameterType); // �V�O�l�`���̕�������^���̕�����ɕϊ� (�z��͌���[]���‚�) + String[] readableTypeSplit = { "", "" }; // �^����[]�̕����p + int firstBracketIndex = readableType.indexOf("[]"); + final int NO_BRACKET_INDEX = -1; + if (firstBracketIndex == NO_BRACKET_INDEX) { + readableTypeSplit[0] = readableType; // �^�� + } else { + readableTypeSplit[0] = readableType.substring(0, firstBracketIndex); // �^�� + readableTypeSplit[1] = readableType.substring(firstBracketIndex); // �^���̌���[]�S�� + } + String tmp = resolveType(type, readableTypeSplit[0]); + if (tmp != null) { + readableTypeSplit[0] = tmp; + } + parameters.add(readableTypeSplit[0] + readableTypeSplit[1]); + } + return parameters; + } +} diff --git a/src/org/ntlab/traceDebugger/MyTreeNode.java b/src/org/ntlab/traceDebugger/MyTreeNode.java new file mode 100644 index 0000000..a8eb255 --- /dev/null +++ b/src/org/ntlab/traceDebugger/MyTreeNode.java @@ -0,0 +1,39 @@ +package org.ntlab.traceDebugger; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import org.eclipse.jface.viewers.TreeNode; + +public class MyTreeNode extends TreeNode { + private List children = new ArrayList<>(); + + public MyTreeNode(Object value) { + super(value); + } + + @Override + public MyTreeNode[] getChildren() { + if (children != null && children.size() == 0) { + return null; + } + return children.toArray(new MyTreeNode[children.size()]); + } + + public List getChildList() { + return children; + } + + @Override + public boolean hasChildren() { + return children != null && children.size() > 0; + } + + public void setChildren(final MyTreeNode[] children) { + this.children = new ArrayList(Arrays.asList(children)); + } + + public void setChildList(final List children) { + this.children = children; + } +} diff --git a/src/org/ntlab/traceDebugger/MyTreeNodeContentProvider.java b/src/org/ntlab/traceDebugger/MyTreeNodeContentProvider.java new file mode 100644 index 0000000..81a2e76 --- /dev/null +++ b/src/org/ntlab/traceDebugger/MyTreeNodeContentProvider.java @@ -0,0 +1,17 @@ +package org.ntlab.traceDebugger; + +import java.util.List; + +import org.eclipse.jface.viewers.TreeNodeContentProvider; + +public class MyTreeNodeContentProvider extends TreeNodeContentProvider { + @Override + public Object[] getElements(final Object inputElement) { + if (inputElement instanceof List) { + List list = (List)inputElement; + MyTreeNode[] nodes = list.toArray(new MyTreeNode[list.size()]); + return super.getElements(nodes); + } + return new Object[0]; + } +} diff --git a/src/org/ntlab/traceDebugger/RadioButtonDialog.java b/src/org/ntlab/traceDebugger/RadioButtonDialog.java new file mode 100644 index 0000000..ca8059e --- /dev/null +++ b/src/org/ntlab/traceDebugger/RadioButtonDialog.java @@ -0,0 +1,55 @@ +package org.ntlab.traceDebugger; + +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Shell; + +public class RadioButtonDialog extends Dialog { + private int selectedIndex = 0; + private String title; + private String[] texts; + + protected RadioButtonDialog(Shell parentShell, String title, String[] texts) { + super(parentShell); + this.title = title; + this.texts = texts; + } + + @Override + public void create() { + super.create(); + getShell().setText(title); + } + + @Override + protected Control createDialogArea(Composite parent) { + Composite composite = (Composite)super.createDialogArea(parent); + Button[] buttons = new Button[texts.length]; + for (int i = 0; i < texts.length; i++) { + final int index = i; + buttons[i] = new Button(parent, SWT.RADIO); +// buttons[i].setLayoutData(new GridData(GridData.FILL_BOTH)); + buttons[i].setAlignment(SWT.CENTER); + buttons[i].setText(texts[i]); + buttons[i].addSelectionListener(new SelectionListener() { + @Override + public void widgetSelected(SelectionEvent e) { + selectedIndex = index; + } + @Override + public void widgetDefaultSelected(SelectionEvent e) { + } + }); + } + return composite; + } + + public String getValue() { + return texts[selectedIndex]; + } +} diff --git a/src/org/ntlab/traceDebugger/TraceBreakPoint.java b/src/org/ntlab/traceDebugger/TraceBreakPoint.java index 720056a..44b17f0 100644 --- a/src/org/ntlab/traceDebugger/TraceBreakPoint.java +++ b/src/org/ntlab/traceDebugger/TraceBreakPoint.java @@ -13,16 +13,24 @@ public class TraceBreakPoint { private List tracePoints = new ArrayList<>(); private String methodSignature; + private String readableSignature; private int lineNo; private List methodExecutions = new ArrayList<>(); private boolean isAvailable = false; -// private int currentIndex = 0; - - public TraceBreakPoint(String methodSignature, int lineNo, long currentTime) { + + private TraceBreakPoint(String methodSignature, int lineNo, boolean isAvailable, String readableSignature) { this.methodSignature = methodSignature; this.lineNo = lineNo; - isAvailable = initTracePoints(methodSignature, lineNo); -// if (isAvailable) forwardIndex(currentTime); + this.isAvailable = isAvailable; + this.readableSignature = readableSignature; + } + + public static TraceBreakPoint createNewTraceBreakPoint(String methodSignature, int lineNo, boolean isAvailable, String readableSignature) + throws IllegalArgumentException { + TraceBreakPoint newTraceBreakPoint = new TraceBreakPoint(methodSignature, lineNo, isAvailable, readableSignature); + boolean isValid = newTraceBreakPoint.initTracePoints(methodSignature, lineNo); + if (!isValid) throw new IllegalArgumentException(); + return newTraceBreakPoint; } private boolean initTracePoints(String methodSignature, int lineNo) { @@ -35,7 +43,7 @@ for (Statement statement : me.getStatements()) { if (statement.getLineNo() == lineNo) { tracePoints.add(me.getTracePoint(order)); -// break; + break; } order++; } @@ -47,8 +55,7 @@ long o1Time = getTime(o1); long o2Time = getTime(o2); return (o1Time < o2Time) ? -1 : 1; - } - + } private long getTime(TracePoint tp) { Statement statement = tp.getStatement(); if (statement instanceof MethodInvocation) { @@ -64,6 +71,33 @@ return methodSignature; } + public String getReadableSignature() { + return readableSignature; +// MethodExecution methodExecution = methodExecutions.iterator().next(); +// String signature = methodExecution.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 = "("; +// String delimiter = ""; +// String[] argArray = signature.split("\\(")[1].split(","); +// for (String arg : argArray) { +// args += (delimiter + arg.substring(arg.lastIndexOf(".") + 1)); +// delimiter = ", "; +// } +// +// StringBuilder sb = new StringBuilder(); +// sb.append(objectType); +// if (!declaringType.equals(objectType)) { +// sb.append("(" + declaringType + ")"); +// } +// sb.append("." + methodName + args); +// return sb.toString(); + } + public int getLineNo() { return lineNo; } @@ -75,70 +109,16 @@ public List getTracePoints() { return tracePoints; } - - + public boolean isAvailable() { return isAvailable; } - public void changeAvailable() { - isAvailable = !isAvailable; + public void setAvailable(boolean isAvailable) { + this.isAvailable = isAvailable; } -// public void reset() { -// initTracePoints(methodSignature, lineNo); -// currentIndex = 0; -// } -// -// public TracePoint peekTracePoint() { -// if ((currentIndex < 0) || (currentIndex >= tracePoints.size())) return null; -// return tracePoints.get(currentIndex); -// } -// -// public TracePoint previousTracePoint() { -// if ((currentIndex - 1 < 0) || (currentIndex - 1 >= tracePoints.size())) return null; -// return tracePoints.get(currentIndex - 1); -// } -// -// public TracePoint dequeueTracePoint(boolean isForward) { -// TracePoint result = null; -// if (isForward) { -// result = peekTracePoint(); -// currentIndex++; -// } else { -// result = previousTracePoint(); -// currentIndex--; -// } -// return result; -// } -// -// public void forwardIndex(long currentTime) { -// int start = currentIndex; -// for (int i = start; i < tracePoints.size(); i++) { -// long time = getTime(tracePoints.get(i).getStatement()); -// if (time > currentTime) { -// currentIndex = i; -// return; -// } -// } -// currentIndex = tracePoints.size(); -// } -// -// public void reverseIndex(long currentTime) { -// for (int i = tracePoints.size() - 1; i >= 0; i--) { -// long time = getTime(tracePoints.get(i).getStatement()); -// if (time <= currentTime) { -// currentIndex = i + 1; -// return; -// } -// } -// currentIndex = 0; -// } -// -// private long getTime(Statement statement) { -// if (statement instanceof MethodInvocation) { -// return ((MethodInvocation)statement).getCalledMethodExecution().getEntryTime(); -// } -// return statement.getTimeStamp(); -// } + public void changeAvailable() { + isAvailable = !isAvailable; + } } diff --git a/src/org/ntlab/traceDebugger/TraceBreakPoints.java b/src/org/ntlab/traceDebugger/TraceBreakPoints.java index 0787f1a..6ce271a 100644 --- a/src/org/ntlab/traceDebugger/TraceBreakPoints.java +++ b/src/org/ntlab/traceDebugger/TraceBreakPoints.java @@ -4,22 +4,31 @@ import java.util.Collections; import java.util.Comparator; import java.util.HashMap; +import java.util.HashSet; import java.util.Iterator; -import java.util.LinkedList; import java.util.List; -import java.util.ListIterator; import java.util.Map; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.debug.core.DebugPlugin; +import org.eclipse.debug.core.model.IBreakpoint; +import org.eclipse.jdt.internal.debug.core.breakpoints.JavaLineBreakpoint; +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.Trace; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; public class TraceBreakPoints { + private Trace trace; private Map> traceBreakPoints = new HashMap<>(); - private List histories = new LinkedList<>(); - private ListIterator historyIt = histories.listIterator(); - private TracePoint curHistPoint; - private int curIdx = -1; + private List histories = new ArrayList<>(); + private TracePoint lastReferencePoint; + + public TraceBreakPoints(Trace trace) { + this.trace = trace; + } public List getAllTraceBreakPoints() { List list = new ArrayList<>(); @@ -38,24 +47,30 @@ return list; } - public boolean addTraceBreakPoint(String methodSignature, int lineNo, long currentTime) { + public boolean addTraceBreakPoint(String inputSignature, int lineNo) { + boolean isSuccess = addTraceBreakPoint(inputSignature, lineNo, true); + return isSuccess; + } + + public boolean addTraceBreakPoint(String inputSignature, int lineNo, boolean isAvailable) { + String methodSignature = findMethodSignaureOnTrace(inputSignature); + if (methodSignature == null) return false; Map innerMap = traceBreakPoints.get(methodSignature); if (innerMap == null) { innerMap = new HashMap<>(); traceBreakPoints.put(methodSignature, innerMap); } - TraceBreakPoint tbp = new TraceBreakPoint(methodSignature, lineNo, currentTime); - if (!tbp.isAvailable()) return false; - innerMap.put(lineNo, tbp); - addHistories(tbp); - return true; + try { + TraceBreakPoint tbp = TraceBreakPoint.createNewTraceBreakPoint(methodSignature, lineNo, isAvailable, inputSignature); + innerMap.put(lineNo, tbp); + addHistories(tbp); + return true; + } catch (IllegalArgumentException e) { + return false; + } } - public boolean addTraceBreakPoint(String methodSignature, int lineNo) { - return addTraceBreakPoint(methodSignature, lineNo, 0L); - } - - public void removeTraceBreakPoint(String methodSignature, int lineNo) { + private void removeTraceBreakPoint(String methodSignature, int lineNo) { Map innerMap = traceBreakPoints.get(methodSignature); if (innerMap == null) return; TraceBreakPoint tbp = innerMap.remove(lineNo); @@ -68,63 +83,85 @@ int lineNo = traceBreakPoint.getLineNo(); removeTraceBreakPoint(methodSignature, lineNo); } - - private void addHistories(TraceBreakPoint tbp) { - ListIterator it = histories.listIterator(); - Iterator tbpIt = tbp.getTracePoints().iterator(); - if (!(tbpIt.hasNext())) return; - TracePoint addedTp = tbpIt.next(); - int idx = 0; - while (it.hasNext()) { - TracePoint tp = it.next(); - if (getTime(addedTp) < getTime(tp)) { - it.previous(); - it.add(addedTp); - if (idx <= curIdx) { - curIdx++; + + public void importBreakpointFromEclipse() { + IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(); + for (IBreakpoint breakpoint : breakpoints) { + if (!(breakpoint instanceof JavaLineBreakpoint)) continue; + try { + IMarker breakpointMarker = breakpoint.getMarker(); + Map attributes = breakpointMarker.getAttributes(); + String type = (String)attributes.get("org.eclipse.jdt.debug.core.typeName"); + type = type.substring(type.lastIndexOf(".") + 1); + int lineNo = (int)attributes.get(IMarker.LINE_NUMBER); + boolean available = (boolean)attributes.get(IBreakpoint.ENABLED); + String message = (String)attributes.get(IMarker.MESSAGE); + String methodName = message.substring(message.indexOf("-") + 2); + methodName = methodName.replace(" ", ""); + String signature; + if (methodName.startsWith(type + "(")) { + signature = methodName; // �R���X�g���N�^���̏ꍇ + } else { + signature = type + "." + methodName; } - addedTp = null; - if (!(tbpIt.hasNext())) break; - addedTp = tbpIt.next(); - } - idx++; - } - if (addedTp != null) { - it.add(addedTp); - while (tbpIt.hasNext()) { - it.add(tbpIt.next()); + addTraceBreakPoint(signature, lineNo, available); + } catch (CoreException e) { + e.printStackTrace(); } } - historyIt = histories.listIterator(curIdx + 1); // ���Ɏ擾����C���f�b�N�X�ɍ��킹���C�e���[�^���Ď擾 + } + + private String findMethodSignaureOnTrace(String inputSignature) { + HashSet methodSignatures = trace.getAllMethodSignatures(); + for (String signature : methodSignatures) { + String signatureFront = signature.substring(0, signature.indexOf("(") + 1); + String inputSignatureFront = inputSignature.substring(0, inputSignature.indexOf("(") + 1); + if (!(signatureFront.endsWith(inputSignatureFront))) continue; + String signatureBack = signature.substring(signature.indexOf("(") + 1); + String[] signatureArgs = signatureBack.split(","); + String inputSignatureBack = inputSignature.substring(inputSignature.indexOf("(") + 1); + String[] inputSignatureArgs = inputSignatureBack.split(","); + if (signatureArgs.length != inputSignatureArgs.length) continue; + boolean isMatch = true; + for (int i = 0; i < signatureArgs.length; i++) { + if (!(signatureArgs[i].endsWith(inputSignatureArgs[i]))) { + isMatch = false; + break; + } + } + if (isMatch) return signature; + } + return null; + } + + private void addHistories(TraceBreakPoint tbp) { + for (TracePoint tp : tbp.getTracePoints()) { + histories.add(tp); + } + Collections.sort(histories, new Comparator() { + @Override + public int compare(TracePoint o1, TracePoint o2) { + long o1Time = getTime(o1); + long o2Time = getTime(o2); + return (o1Time < o2Time) ? -1 : 1; + } + private long getTime(TracePoint tp) { + Statement statement = tp.getStatement(); + if (statement instanceof MethodInvocation) { + return ((MethodInvocation)statement).getCalledMethodExecution().getEntryTime(); + } + return statement.getTimeStamp(); + } + }); confirm(); } private void removeHistories(TraceBreakPoint tbp) { - ListIterator it = histories.listIterator(); - Iterator tbpIt = tbp.getTracePoints().iterator(); - if (!(tbpIt.hasNext())) return; - TracePoint removedTp = tbpIt.next(); - int idx = 0; + List removedPoints = tbp.getTracePoints(); + Iterator it = histories.iterator(); while (it.hasNext()) { TracePoint tp = it.next(); - if (tp.equals(removedTp)) { - it.remove(); - if (tp.equals(curHistPoint)) { - curHistPoint = null; // ���݈ʒu�ɑΉ�����u���[�N�|�C���g���폜���ꂽ�ꍇ�͌��݈ʒu���Ȃ��ɂ��� - curIdx = -1; - } else if (-1 < curIdx && idx <= curIdx) { - curIdx--; - } - if (!(tbpIt.hasNext())) break; - removedTp = tbpIt.next(); - } else { - idx++; - } - } - if (curHistPoint == null) { - historyIt = null; - } else { - historyIt = histories.listIterator(curIdx + 1); // ���Ɏ擾����C���f�b�N�X�ɍ��킹���C�e���[�^���Ď擾 + if (removedPoints.contains(tp)) it.remove(); } confirm(); } @@ -134,87 +171,33 @@ } public TracePoint getNextTracePoint(long time) { - long curHistTime; - if (curHistPoint == null) { - curHistTime = 0L; - curIdx = -1; - historyIt = histories.listIterator(); - } else { - curHistTime = getTime(curHistPoint); - } - if (curHistTime <= time) { - while (historyIt.hasNext()) { - TracePoint tp = historyIt.next(); - if (tp.equals(curHistPoint)) continue; - curHistPoint = tp; - curIdx++; - if (!checkAvailable(curHistPoint)) continue; - curHistTime = getTime(curHistPoint); - if (curHistTime > time) { - confirm(); - return curHistPoint; - } + for (TracePoint tp : histories) { + if (!(checkAvailable(tp))) continue; + if (getTime(tp) > time) { + lastReferencePoint = tp; + confirm(); + return tp.duplicate(); } - } else { - while (historyIt.hasPrevious()) { - TracePoint tp = historyIt.previous(); - if (tp.equals(curHistPoint)) continue; - curIdx--; - if (!checkAvailable(tp)) continue; - curHistTime = getTime(tp); - if (curHistTime <= time) { - confirm(); - return curHistPoint; - } - curHistPoint = tp; - } - confirm(); - return curHistPoint; } + lastReferencePoint = null; confirm(); return null; } public TracePoint getPreviousTracePoint(long time) { - long curHistTime; - if (curHistPoint == null) { - curHistTime = Long.MAX_VALUE; - curIdx = histories.size(); - historyIt = histories.listIterator(histories.size()); - } else { - curHistTime = getTime(curHistPoint); - } - if (curHistTime >= time) { - while (historyIt.hasPrevious()) { - TracePoint tp = historyIt.previous(); - if (tp.equals(curHistPoint)) continue; - curHistPoint = tp; - curIdx--; - if (!checkAvailable(curHistPoint)) continue; - curHistTime = getTime(curHistPoint); - if (curHistTime < time) { - confirm(); - return curHistPoint; - } + TracePoint tmp = null; + for (TracePoint tp : histories) { + if (!(checkAvailable(tp))) continue; + if (getTime(tp) >= time) { + lastReferencePoint = tmp; + confirm(); + return (tmp != null) ? tmp.duplicate() : null; } - } else { - while (historyIt.hasNext()) { - TracePoint tp = historyIt.next(); - if (tp.equals(curHistPoint)) continue; - curIdx++; - if (!checkAvailable(tp)) continue; - curHistTime = getTime(tp); - if (curHistTime >= time) { - confirm(); - return curHistPoint; - } - curHistPoint = tp; - } - confirm(); - return curHistPoint; + tmp = tp; } + lastReferencePoint = tmp; confirm(); - return null; + return (tmp != null) ? tmp.duplicate() : null; } private TraceBreakPoint getTraceBreakPoint(TracePoint tp) { @@ -228,19 +211,9 @@ TraceBreakPoint tbp = getTraceBreakPoint(tp); return (tbp != null) ? tbp.isAvailable() : false; } - - public void reset() { - curIdx = -1; - historyIt = histories.listIterator(); - curHistPoint = null; - } public void clear() { traceBreakPoints.clear(); - histories.clear(); - curIdx = -1; - historyIt = null; - curHistPoint = null; } private long getTime(TracePoint tp) { @@ -250,91 +223,23 @@ } return statement.getTimeStamp(); } - + private void confirm() { System.out.println(); - if (curHistPoint == null) { + if (lastReferencePoint == null) { System.out.println("cur: " + "Not Exist"); } else { - System.out.println("cur: " + getTime(curHistPoint)); + System.out.println("cur: " + getTime(lastReferencePoint)); } - int idx = 0; for (TracePoint tp : histories) { String signature = tp.getMethodExecution().getSignature(); int lineNo = tp.getStatement().getLineNo(); long time = getTime(tp); - String idxStr = (idx == curIdx) ? "����������" : ""; - System.out.println(time + " " + signature + " line: " + lineNo + " " + idxStr); - idx++; + StringBuilder msg = new StringBuilder(); + msg.append(time + " " + signature + " line: " + lineNo); + if (tp.equals(lastReferencePoint)) msg.append(" ����������"); + System.out.println(msg); } System.out.println(); - } - -// public TracePoint getNextTracePoint(long currentTime) { -// TraceBreakPoint resultTbp = null; -// long resultTpTime = 0L; -// for (Map innerMap : traceBreakPoints.values()) { -// for (TraceBreakPoint tbp: innerMap.values()) { -// if (!tbp.isAvailable()) continue; -// TracePoint tp = tbp.peekTracePoint(); -// if (tp == null) continue; -// long tpTime = tp.getStatement().getTimeStamp(); -// if (tpTime <= currentTime) continue; -// if (resultTbp == null) { -// resultTbp = tbp; -// resultTpTime = tp.getStatement().getTimeStamp(); -// } else if (tpTime < resultTpTime) { -// resultTbp = tbp; -// resultTpTime = tp.getStatement().getTimeStamp(); -// } -// } -// } -// return (resultTbp != null) ? resultTbp.dequeueTracePoint(true) : null; -// } -// -// public TracePoint getPreviousTracePoint(long currentTime) { -// TraceBreakPoint resultTbp = null; -// long resultTpTime = 0L; -// for (Map innerMap : traceBreakPoints.values()) { -// for (TraceBreakPoint tbp: innerMap.values()) { -// if (!tbp.isAvailable()) continue; -// TracePoint tp = tbp.previousTracePoint(); -// if (tp == null) continue; -// long tpTime = tp.getStatement().getTimeStamp(); -// if (tpTime >= currentTime) continue; -// if (resultTbp == null) { -// resultTbp = tbp; -// resultTpTime = tp.getStatement().getTimeStamp(); -// } else if (tpTime > resultTpTime) { -// resultTbp = tbp; -// resultTpTime = tp.getStatement().getTimeStamp(); -// } -// } -// } -// return (resultTbp != null) ? resultTbp.dequeueTracePoint(false) : null; -// } -// -// public void forwardAll(long currentTime) { -// for (Map innerMap : traceBreakPoints.values()) { -// for (TraceBreakPoint tbp : innerMap.values()) { -// tbp.forwardIndex(currentTime); -// } -// } -// } -// -// public void reverseAll(long currentTime) { -// for (Map innerMap : traceBreakPoints.values()) { -// for (TraceBreakPoint tbp : innerMap.values()) { -// tbp.reverseIndex(currentTime); -// } -// } -// } -// -// public void resetAll() { -// for (Map innerMap : traceBreakPoints.values()) { -// for (TraceBreakPoint tbp : innerMap.values()) { -// tbp.reset(); -// } -// } -// } + } } diff --git a/src/org/ntlab/traceDebugger/TraceDebuggerPerspective.java b/src/org/ntlab/traceDebugger/TraceDebuggerPerspective.java index f96cd55..eee7a31 100644 --- a/src/org/ntlab/traceDebugger/TraceDebuggerPerspective.java +++ b/src/org/ntlab/traceDebugger/TraceDebuggerPerspective.java @@ -11,16 +11,16 @@ // �G�f�B�^�̏ꏊ���擾 String editorArea = layout.getEditorArea(); - // ����ɃR�[���X�^�b�N�̃r���[��z�u - IFolderLayout topLeft = layout.createFolder("topLeft", IPageLayout.TOP, 0.35f, editorArea); - topLeft.addView(CallStackView.ID); + // �E�Ƀu���[�N�|�C���g�̃r���[��z�u + IFolderLayout breakpointViewArea = layout.createFolder("BreakPointViewArea", IPageLayout.RIGHT, 0.5f, editorArea); + breakpointViewArea.addView(BreakPointView.ID); - // �E��Ƀu���[�N�|�C���g�̃r���[��z�u - IFolderLayout topRight = layout.createFolder("topRight", IPageLayout.RIGHT, 0.5f, "topLeft"); - topRight.addView(BreakPointView.ID); + // ����ɃR�[���X�^�b�N�̃r���[��z�u + IFolderLayout callStackViewArea = layout.createFolder("CallStackViewArea", IPageLayout.TOP, 0.25f, editorArea); + callStackViewArea.addView(CallStackView.ID); // �E��ɕϐ��̃r���[��z�u - IFolderLayout topRight2 = layout.createFolder("topRight2", IPageLayout.RIGHT, 0.5f, "topLeft"); - topRight2.addView(VariableView.ID); + IFolderLayout variableViewArea = layout.createFolder("VariableViewArea", IPageLayout.TOP, 0.25f, "BreakPointViewArea"); + variableViewArea.addView(VariableView.ID); } } diff --git a/src/org/ntlab/traceDebugger/TraceDebuggerPerspectiveRelatedDelta.java b/src/org/ntlab/traceDebugger/TraceDebuggerPerspectiveRelatedDelta.java new file mode 100644 index 0000000..f08f732 --- /dev/null +++ b/src/org/ntlab/traceDebugger/TraceDebuggerPerspectiveRelatedDelta.java @@ -0,0 +1,34 @@ +package org.ntlab.traceDebugger; + +import org.eclipse.ui.IFolderLayout; +import org.eclipse.ui.IPageLayout; +import org.eclipse.ui.IPerspectiveFactory; + +public class TraceDebuggerPerspectiveRelatedDelta implements IPerspectiveFactory { + + @Override + public void createInitialLayout(IPageLayout layout) { + // �G�f�B�^�̏ꏊ���擾 + String editorArea = layout.getEditorArea(); + + // �E�Ƀu���[�N�|�C���g�̃r���[��z�u + IFolderLayout breakpointViewArea = layout.createFolder("BreakpointViewArea", IPageLayout.RIGHT, 0.5f, editorArea); + breakpointViewArea.addView(BreakPointViewRelatedDelta.ID); + + // ����ɃR�[���c���[�̃r���[��z�u + IFolderLayout callTreeViewArea = layout.createFolder("CallTreeViewArea", IPageLayout.BOTTOM, 0.25f, "BreakpointViewArea"); + callTreeViewArea.addView(CallTreeView.ID); + + // �E���Ƀg���[�X�|�C���g�̃r���[��z�u + IFolderLayout tracePointsViewArea = layout.createFolder("TracePointsViewArea", IPageLayout.BOTTOM, 0.5f, "CallTreeViewArea"); + tracePointsViewArea.addView(TracePointsView.ID); + + // �E��ɕϐ��̃r���[��z�u + IFolderLayout variableViewArea = layout.createFolder("VariableViewArea", IPageLayout.TOP, 0.25f, editorArea); + variableViewArea.addView(VariableViewRelatedDelta.ID); + + // ����ɃR�[���X�^�b�N�̃r���[��z�u + IFolderLayout callStackViewArea = layout.createFolder("CallStackViewArea", IPageLayout.LEFT, 0.25f, "VariableViewArea"); + callStackViewArea.addView(CallStackViewRelatedDelta.ID); + } +} diff --git a/src/org/ntlab/traceDebugger/TraceDebuggerPlugin.java b/src/org/ntlab/traceDebugger/TraceDebuggerPlugin.java index dd5ad9a..d14f836 100644 --- a/src/org/ntlab/traceDebugger/TraceDebuggerPlugin.java +++ b/src/org/ntlab/traceDebugger/TraceDebuggerPlugin.java @@ -1,8 +1,18 @@ package org.ntlab.traceDebugger; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.resource.ImageRegistry; +import org.eclipse.ui.IViewPart; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.PlatformUI; import org.eclipse.ui.plugin.AbstractUIPlugin; import org.ntlab.traceDebugger.analyzerProvider.AbstractAnalyzer; -import org.ntlab.traceDebugger.analyzerProvider.ObjectFlowAnalyzer; import org.osgi.framework.BundleContext; /** @@ -11,11 +21,16 @@ public class TraceDebuggerPlugin extends AbstractUIPlugin { // The plug-in ID - public static final String PLUGIN_ID = "org.ntlab.helloWorld"; //$NON-NLS-1$ + public static final String PLUGIN_ID = "org.ntlab.traceDebugger"; //$NON-NLS-1$ -// private static ObjectFlowAnalyzer objectFlowAnalyzer; private static AbstractAnalyzer analyzer; + private static int uniqueIdForViews = 0; + + private static Map> viewIdToAllViews = new HashMap<>(); + + private static Map viewIdToActiveView = new HashMap<>(); + // The shared instance private static TraceDebuggerPlugin plugin; @@ -51,20 +66,64 @@ public static TraceDebuggerPlugin getDefault() { return plugin; } - -// public static ObjectFlowAnalyzer getObjectFlowAnalyzer() { -// return objectFlowAnalyzer; -// } -// -// public static void setObjectFlowAnalyzer(ObjectFlowAnalyzer objectFlowAnalyzer) { -// TraceDebuggerPlugin.objectFlowAnalyzer = objectFlowAnalyzer; -// } public static AbstractAnalyzer getAnalyzer() { return analyzer; } + public static IViewPart getActiveView(String viewId) { + return viewIdToActiveView.get(viewId); + } + + public static Map> getAllViews() { + return viewIdToAllViews; + } + + public static Set getViews(String viewId) { + return viewIdToAllViews.get(viewId); + } + public static void setAnalyzer(AbstractAnalyzer analyzer) { TraceDebuggerPlugin.analyzer = analyzer; } + + public static void setActiveView(String viewId, IViewPart activeView) { + viewIdToActiveView.put(viewId, activeView); + addView(viewId, activeView); + } + + private static void addView(String viewId, IViewPart view) { + Set views = viewIdToAllViews.get(viewId); + if (views == null) { + views = new HashSet(); + viewIdToAllViews.put(viewId, views); + } + views.add(view); + } + + public static IViewPart createNewView(String viewId, int mode) { + String secondaryId = "View" + (uniqueIdForViews++); + IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); + try { + return workbenchPage.showView(viewId, secondaryId, mode); + } catch (PartInitException e) { + throw new RuntimeException(e); + } + } + + @Override + protected void initializeImageRegistry(ImageRegistry reg) { + reg.put(BreakPointViewRelatedDelta.STEP_BACK_INTO_ELCL, getImageDescriptor("/icons/debug/stepbackinto_elcl.png")); + reg.put(BreakPointViewRelatedDelta.STEP_BACK_INTO_DLCL, getImageDescriptor("/icons/debug/stepbackinto_dlcl.png")); + reg.put(BreakPointViewRelatedDelta.STEP_BACK_OVER_ELCL, getImageDescriptor("/icons/debug/stepbackover_elcl.png")); + reg.put(BreakPointViewRelatedDelta.STEP_BACK_OVER_DLCL, getImageDescriptor("/icons/debug/stepbackover_dlcl.png")); + reg.put(BreakPointViewRelatedDelta.STEP_BACK_RETURN_ELCL, getImageDescriptor("/icons/debug/stepbackreturn_elcl.png")); + reg.put(BreakPointViewRelatedDelta.STEP_BACK_RETURN_DLCL, getImageDescriptor("/icons/debug/stepbackreturn_dlcl.png")); + reg.put(BreakPointViewRelatedDelta.BACK_RESUME_ELCL, getImageDescriptor("/icons/debug/backresume_elcl.png")); + reg.put(BreakPointViewRelatedDelta.BACK_RESUME_DLCL, getImageDescriptor("/icons/debug/backresume_dlcl.png")); + } + + public static ImageDescriptor getImageDescriptor(String path) { + return imageDescriptorFromPlugin(PLUGIN_ID, path); + } } diff --git a/src/org/ntlab/traceDebugger/TracePoints.java b/src/org/ntlab/traceDebugger/TracePoints.java new file mode 100644 index 0000000..45f3a19 --- /dev/null +++ b/src/org/ntlab/traceDebugger/TracePoints.java @@ -0,0 +1,30 @@ +package org.ntlab.traceDebugger; + +import java.util.ArrayList; +import java.util.List; + +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; + +public class TracePoints { + List tracePoints = new ArrayList<>(); + + public List get() { + return tracePoints; + } + + public TracePoint[] getToArray() { + return tracePoints.toArray(new TracePoint[tracePoints.size()]); + } + + public void add(TracePoint tp) { + tracePoints.add(tp); + } + + public void remove(TracePoint tp) { + tracePoints.remove(tp); + } + + public void clear() { + tracePoints.clear(); + } +} diff --git a/src/org/ntlab/traceDebugger/TracePointsLabelProvider.java b/src/org/ntlab/traceDebugger/TracePointsLabelProvider.java new file mode 100644 index 0000000..17d420a --- /dev/null +++ b/src/org/ntlab/traceDebugger/TracePointsLabelProvider.java @@ -0,0 +1,62 @@ +package org.ntlab.traceDebugger; + +import org.eclipse.jface.viewers.ITableLabelProvider; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.swt.graphics.Image; +import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.PlatformUI; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; + +public class TracePointsLabelProvider extends LabelProvider implements ITableLabelProvider { + + @Override + public String getColumnText(Object element, int columnIndex) { + if (element instanceof TracePoint) { + TracePoint tp = (TracePoint)element; + switch (columnIndex) { + case 0: + return String.valueOf(tp.getStatement().getLineNo()); + case 1: + return getReadableSignature(tp.getMethodExecution()); + } + } + return "�e�X�g�p�e�L�X�g" + columnIndex; + } + + @Override + public Image getColumnImage(Object element, int columnIndex) { + return getImage(element); + } + + @Override + public Image getImage(Object element) { + return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); + } + + private String getReadableSignature(MethodExecution methodExecution) { + String signature = methodExecution.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 = "("; + String delimiter = ""; + String[] argArray = signature.split("\\(")[1].split(","); + for (String arg : argArray) { + args += (delimiter + arg.substring(arg.lastIndexOf(".") + 1)); + delimiter = ", "; + } + + StringBuilder sb = new StringBuilder(); + sb.append(objectType); + if (!declaringType.equals(objectType)) { + sb.append("(" + declaringType + ")"); + } + sb.append("." + methodName + args); + return sb.toString(); + } +} \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/TracePointsView.java b/src/org/ntlab/traceDebugger/TracePointsView.java new file mode 100644 index 0000000..0bb3b5c --- /dev/null +++ b/src/org/ntlab/traceDebugger/TracePointsView.java @@ -0,0 +1,199 @@ +package org.ntlab.traceDebugger; + +import java.util.List; +import java.util.Map; + +import org.eclipse.core.resources.IMarker; +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.action.IMenuListener; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.IToolBarManager; +import org.eclipse.jface.action.MenuManager; +import org.eclipse.jface.viewers.ArrayContentProvider; +import org.eclipse.jface.viewers.DoubleClickEvent; +import org.eclipse.jface.viewers.IDoubleClickListener; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.SelectionChangedEvent; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Menu; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableColumn; +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.DeltaExtractionAnalyzer; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; + +public class TracePointsView extends ViewPart { + private TableViewer viewer; + private Shell shell; + private IAction addAction; + private IAction removeAction; + private IAction jumpAction; + private TracePoint selectedTp; + private TracePoints tracePoints = new TracePoints(); + public static final String ID = "org.ntlab.traceDebugger.tracePointsView"; + + public TracePointsView() { + // TODO Auto-generated constructor stub + System.out.println("BreakPointView�N���X���������ꂽ��!"); + } + + @Override + public void createPartControl(Composite parent) { + // TODO Auto-generated method stub + System.out.println("TracePointsView#createPartControl(Composite)���Ă΂ꂽ��!"); + shell = parent.getShell(); + viewer = new TableViewer(parent, SWT.FULL_SELECTION); + Table table = viewer.getTable(); + table.setHeaderVisible(true); + table.setLinesVisible(true); + + // �e�[�u���̃J�������쐬 + String[] tableColumnTexts = {"Line", "Signature"}; + int[] tableColumnWidth = {80, 1000}; + TableColumn[] tableColumns = new TableColumn[tableColumnTexts.length]; + for (int i = 0; i < tableColumns.length; i++) { + tableColumns[i] = new TableColumn(table, SWT.NULL); + tableColumns[i].setText(tableColumnTexts[i]); + tableColumns[i].setWidth(tableColumnWidth[i]); + } + viewer.setContentProvider(new ArrayContentProvider()); + viewer.setLabelProvider(new TracePointsLabelProvider()); + viewer.addSelectionChangedListener(new ISelectionChangedListener() { + @Override + public void selectionChanged(SelectionChangedEvent event) { + IStructuredSelection sel = (IStructuredSelection)event.getSelection(); + Object element = sel.getFirstElement(); + if (element instanceof TracePoint) { + selectedTp = (TracePoint)element; + MethodExecution me = selectedTp.getMethodExecution(); + int lineNo = selectedTp.getStatement().getLineNo(); + JavaEditorOperator.openSrcFileOfMethodExecution(me, lineNo); + } + } + }); + viewer.addDoubleClickListener(new IDoubleClickListener() { + @Override + public void doubleClick(DoubleClickEvent event) { + IStructuredSelection sel = (IStructuredSelection)event.getSelection(); + Object element = sel.getFirstElement(); + if (element instanceof TracePoint) { + selectedTp = (TracePoint)element; + if (DebuggingController.getInstance().isRunning()) { + jumpToTheTracePoint(selectedTp); + } + } + } + }); + + createActions(); + createToolBar(); + createMenuBar(); + createPopupMenu(); + TraceDebuggerPlugin.setActiveView(ID, this); + } + + @Override + public void setFocus() { + // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); + viewer.getControl().setFocus(); + } + + private void createActions() { + addAction = new Action() { + @Override + public void run() { + DebuggingController debuggingController = DebuggingController.getInstance(); + TracePoint currentTp = debuggingController.getCurrentTp(); + addTracePoint(currentTp); + } + }; + addAction.setText("Add"); + addAction.setToolTipText("Add"); + + removeAction = new Action() { + @Override + public void run() { + if (selectedTp != null) { + tracePoints.remove(selectedTp); + update(); + } + } + }; + removeAction.setText("Remove"); + removeAction.setToolTipText("Remove"); + + jumpAction = new Action() { + @Override + public void run() { + if (selectedTp != null && DebuggingController.getInstance().isRunning()) { + jumpToTheTracePoint(selectedTp); + } + } + }; + jumpAction.setText("Jump"); + jumpAction.setToolTipText("Jump"); + } + + private void createToolBar() { + IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); + mgr.add(addAction); + mgr.add(removeAction); + mgr.add(jumpAction); + } + + private void createMenuBar() { + IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); + mgr.add(addAction); + mgr.add(removeAction); + mgr.add(jumpAction); + } + + private void createPopupMenu() { + MenuManager menuMgr = new MenuManager("#PopupMenu"); + menuMgr.setRemoveAllWhenShown(true); + menuMgr.addMenuListener(new IMenuListener() { + @Override + public void menuAboutToShow(IMenuManager manager) { +// manager.add(addAction); +// manager.add(removeAction); +// manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); + } + }); + Menu menu = menuMgr.createContextMenu(viewer.getControl()); + viewer.getControl().setMenu(menu); + getSite().registerContextMenu(menuMgr, viewer); + } + + public void addTracePoint(TracePoint tp) { + tracePoints.add(tp); + update(); + } + + public void reset() { + tracePoints.clear(); + update(); + } + + private void update() { + viewer.setInput(tracePoints.getToArray()); + viewer.refresh(); + } + + protected void jumpToTheTracePoint(TracePoint tp) { + DebuggingController debuggingController = DebuggingController.getInstance(); + debuggingController.jumpToTheTracePoint(tp, false); + MethodExecution currentME = tp.getMethodExecution(); + int lineNo = tp.getStatement().getLineNo(); + IMarker marker = DebuggingController.getInstance().createCurrentLineMarker(currentME, lineNo); + JavaEditorOperator.markAndOpenJavaFile(marker); + } +} \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/Variable.java b/src/org/ntlab/traceDebugger/Variable.java index 413bf50..515a915 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; @@ -14,37 +16,100 @@ import org.ntlab.traceAnalysisPlatform.tracer.trace.FieldUpdate; import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; +import org.ntlab.traceDebugger.analyzerProvider.VariableUpdatePointFinder; public class Variable { private String variableName; - private String className; - private String id; + private VariableType variableType; + private String fullyQualifiedVariableName; + private String valueClassName; + private String valueId; private Variable parent; private List children = new ArrayList<>(); private String containerClassName; private String containerId; - private TracePoint tracePoint; + private TracePoint lastUpdatePoint; + private TracePoint before; private boolean isReturned; private DeepHierarchy deepHierarchy; private boolean alreadyCreatedChildHierarchy = false; private boolean alreadyCreatedGrandChildHierarchy = false; + private Map additionalAttributes = new HashMap<>(); + public static final String NULL_VALUE = "null"; + public static final String RETURN_VARIABLE_NAME = "return"; + public static final String ARG_VARIABLE_NAME = "arg"; + public static final String RECEIVER_VARIABLE_NAME = "receiver"; + public static final String VALUE_VARIABLE_NAME = "value"; + public static final String CONTAINER_VARIABLE_NAME = "container"; + + public enum VariableType { + USE_VALUE, USE_CONTAINER, USE_RECEIVER, USE_RETURN, + DEF_VALUE, DEF_CONTAINER, DEF_RECEIVER, DEF_ARG, + PARAMETER; + public boolean isContainerSide() { + return this.equals(USE_CONTAINER) || this.equals(DEF_CONTAINER) + || this.equals(USE_RECEIVER) || this.equals(DEF_RECEIVER); + } + public boolean isDef() { + return this.equals(DEF_CONTAINER) || this.equals(DEF_VALUE) + || this.equals(DEF_RECEIVER) || this.equals(DEF_ARG); + } + public boolean isUse() { + return this.equals(USE_CONTAINER) || this.equals(USE_VALUE) + || this.equals(USE_RECEIVER) || this.equals(USE_RETURN); + } + } public Variable(String variableName, String containerClassName, String containerId, - String className, String id, TracePoint before, boolean isReturned) { + String valueClassName, String valueId, TracePoint before, boolean isReturned) { + this(variableName, containerClassName, containerId, valueClassName, valueId, before, isReturned, VariableType.USE_VALUE); + } + + public Variable(String variableName, String containerClassName, String containerId, + String valueClassName, String valueId, TracePoint before, boolean isReturned, VariableType variableType) { + init(variableName, variableName, containerClassName, containerId, valueClassName, valueId, null, before, isReturned, variableType); + } + + public Variable(String variableName, String fullyQualifiedVariableName, String containerClassName, String containerId, + String valueClassName, String valueId, TracePoint lastUpdatePoint, TracePoint before, boolean isReturned, VariableType variableType) { + init(variableName, fullyQualifiedVariableName, containerClassName, containerId, valueClassName, valueId, lastUpdatePoint, before, isReturned, variableType); + } + + private void init(String variableName, String fullyQualifiedVariableName, String containerClassName, String containerId, + String valueClassName, String valueId, TracePoint lastUpdatePoint, TracePoint before, boolean isReturned, VariableType variableType) { this.variableName = variableName; + this.fullyQualifiedVariableName = fullyQualifiedVariableName; this.containerClassName = containerClassName; this.containerId = containerId; - this.className = className; - this.id = id; - this.tracePoint = before; + this.valueClassName = valueClassName; + this.valueId = valueId; + this.lastUpdatePoint = lastUpdatePoint; + this.before = before; this.isReturned = isReturned; this.deepHierarchy = checkDeepHierarchy(); + this.alreadyCreatedChildHierarchy = false; + this.alreadyCreatedGrandChildHierarchy = false; + this.children.clear(); + this.additionalAttributes.clear(); + this.variableType = variableType; + } + + public void update(String valueClassName, String valueId, TracePoint lastUpdatePoint, boolean isReturned) { + init(variableName, fullyQualifiedVariableName, containerClassName, containerId, valueClassName, valueId, lastUpdatePoint, lastUpdatePoint, isReturned, variableType); } public String getVariableName() { return variableName; } + public VariableType getVariableType() { + return variableType; + } + + public String getFullyQualifiedVariableName() { + return fullyQualifiedVariableName; + } + public String getContainerClassName() { return containerClassName; } @@ -53,16 +118,20 @@ return containerId; } - public String getClassName() { - return className; + public String getValueClassName() { + return valueClassName; } - public String getId() { - return id; + public String getValueId() { + return valueId; } - public TracePoint getTracePoint() { - return tracePoint; + public TracePoint getLastUpdatePoint() { + return lastUpdatePoint; + } + + public TracePoint getBeforeTracePoint() { + return before; } public Variable getParent() { @@ -80,7 +149,7 @@ @Override public String toString() { - return variableName + ": " + className + "(" + "id = " + id + ")"; + return variableName + ": " + valueClassName + "(" + "id = " + valueId + ")"; } /** @@ -92,20 +161,20 @@ */ private DeepHierarchy checkDeepHierarchy() { // �t�B�[���h��ID��Type���Ȃ��ꍇ��AType(=ActualType)��"---"�̏ꍇ�͉������Ȃ� - if (this.getId() == null || this.getId().isEmpty() - || this.getClassName() == null || this.getClassName().isEmpty()) { + if (this.getValueId() == null || this.getValueId().isEmpty() + || this.getValueClassName() == null || this.getValueClassName().isEmpty()) { return DeepHierarchy.NONE; } final String NULL_ACTUAL_TYPE = "---"; // �t�B�[���h�ɑ΂��Ė����I��null����ꂽ�ꍇ��ActualType�̎擾������ - if (this.getClassName().equals(NULL_ACTUAL_TYPE)) return DeepHierarchy.NONE; + if (this.getValueClassName().equals(NULL_ACTUAL_TYPE)) return DeepHierarchy.NONE; final String ARRAY_SIGNATURE_HEAD = "["; // �z��̃V�O�l�`���̐擪�́A�z��̎��������� [ ���A�Ȃ� - if (this.getClassName().startsWith(ARRAY_SIGNATURE_HEAD)) { + if (this.getValueClassName().startsWith(ARRAY_SIGNATURE_HEAD)) { // �t�B�[���h��Type���z��^(�@[ �Ŏn�܂�@)�ꍇ (���̔z�񂪎��Še�v�f�ɂ‚��Ă���Ȃ�f�[�^�擾�������Ăяo��) return DeepHierarchy.ARRAY; } else { String[] primitives = {"byte", "short", "int", "long", "float", "double", "char", "boolean"}; - if (!Arrays.asList(primitives).contains(this.getClassName())) { + if (!Arrays.asList(primitives).contains(this.getValueClassName())) { // �t�B�[���h��Type���Q�ƌ^(=�I�u�W�F�N�g)�̏ꍇ (���̃I�u�W�F�N�g�������Ă���t�B�[���h�ɂ‚��Ă���Ȃ�f�[�^�擾�������Ăяo��) return DeepHierarchy.FIELD; } @@ -154,16 +223,41 @@ } alreadyCreatedChildHierarchy = true; } - + private void getFieldsState() { // �t�B�[���h��ID��Type���擾���ĕ\�� - TraceJSON trace = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); - String declaringClassName = className; - IType type = JavaEditorOperator.findIType(null, declaringClassName); - if (type == null) { - System.out.println("IType == null: " + declaringClassName); - return; + IType type = null; + if (variableType.isContainerSide()) { + type = JavaElementFinder.findIType(null, containerClassName); + } else { + type = JavaElementFinder.findIType(null, valueClassName); } + if (type == null) return; + getFieldsState(type); + getFieldStateForSuperClass(type); // �e�N���X��k���Ă����A�����̃N���X�Œ�`���ꂽ�t�B�[���h�̏����擾���Ă��� (�������������������Ĕ��ɏd���Ȃ�) + } + + /** + * // �e�N���X��k���Ă����A�����̃N���X�Œ�`���ꂽ�t�B�[���h�̏����擾���Ă��� (�������������������Ĕ��ɏd���Ȃ�) + * @param type �N�_�ƂȂ�N���X + */ + private void getFieldStateForSuperClass(IType type) { + try { + while (true) { + String superClassName = type.getSuperclassName(); + if (superClassName == null) break; + String fullyQualifiedSuperClassName = JavaElementFinder.resolveType(type, superClassName); + if (fullyQualifiedSuperClassName == null) break; + type = JavaElementFinder.findIType(null, fullyQualifiedSuperClassName); + if (type == null) break; + getFieldsState(type); + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + } + + private void getFieldsState(IType type) { try { for (IField field : type.getFields()) { if (Flags.isStatic(field.getFlags())) continue; @@ -171,14 +265,25 @@ String fullyQualifiedFieldName = field.getDeclaringType().getFullyQualifiedName() + "." + field.getElementName(); // ���S����N���X�� // ���̃t�B�[���h�ɂ‚��Ă̍ŐV�̍X�V�����擾(FieldUpdate) + TraceJSON trace = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); // FieldUpdate fieldUpdate = trace.getRecentlyFieldUpdate(thisObjData.getId(), fieldName, tp); - FieldUpdate fieldUpdate = trace.getFieldUpdate(id, fullyQualifiedFieldName, tracePoint, isReturned); - - // �t�B�[���h��ID��Type���擾(String) - String fieldObjId = (fieldUpdate != null) ? fieldUpdate.getValueObjId() : "0"; - String fieldType = (fieldUpdate != null) ? fieldUpdate.getValueClassName() : "---"; - Variable fieldData = new Variable(fieldName, className, id, fieldType, fieldObjId, tracePoint, isReturned); - this.addChild(fieldData); +// FieldUpdate fieldUpdate = trace.getFieldUpdate(id, fullyQualifiedFieldName, before, isReturned); + +// TracePoint updateTracePoint = trace.getFieldUpdateTracePoint(valueId, fullyQualifiedFieldName, before, isReturned); + TracePoint updateTracePoint = VariableUpdatePointFinder.getInstance().getPoint(valueId, fullyQualifiedFieldName, before); + +// if (updateTracePoint == null) continue; + if (updateTracePoint != null) { + FieldUpdate fieldUpdate = (FieldUpdate)updateTracePoint.getStatement(); + // �t�B�[���h��ID��Type���擾(String) + String fieldObjId = (fieldUpdate != null) ? fieldUpdate.getValueObjId() : "---"; + String fieldType = (fieldUpdate != null) ? fieldUpdate.getValueClassName() : NULL_VALUE; + Variable fieldData = new Variable(fieldName, fullyQualifiedFieldName, valueClassName, valueId, fieldType, fieldObjId, updateTracePoint, before, isReturned, VariableType.USE_VALUE); + this.addChild(fieldData); + } else { + Variable fieldData = new Variable(fieldName, fullyQualifiedFieldName, valueClassName, valueId, NULL_VALUE, "---", updateTracePoint, before, isReturned, VariableType.USE_VALUE); + this.addChild(fieldData); + } } } catch (JavaModelException e) { e.printStackTrace(); @@ -189,22 +294,30 @@ TraceJSON trace = (TraceJSON)TraceDebuggerPlugin.getAnalyzer().getTrace(); for (int i = 0;; i++){ // ���̔z��v�f�ɂ‚��Ă̍ŐV�̍X�V�����擾(ArrayUpdate) - ArrayUpdate arrayUpdate = trace.getRecentlyArrayUpdate(id, i, tracePoint); + ArrayUpdate arrayUpdate = trace.getRecentlyArrayUpdate(valueId, i, before); if (arrayUpdate == null) { // �z��̃T�C�Y���擾�ł��Ȃ����߁A�C���f�b�N�X���T�C�Y���߂̂Ƃ��Ɋm���ɔ���������@�Ƃ��ĉ����� // �������A�z��v�f�̓r���ɖ���`���������ꍇ�ł��A�����Ă��܂��̂����_ break; } - String arrayIndexName = this.getVariableName() + "[" + i + "]"; + String arrayIndexName = variableName + "[" + i + "]"; // �z��v�f��ID��Type���擾(String) String valueObjId = arrayUpdate.getValueObjectId(); String valueType = arrayUpdate.getValueClassName(); - Variable arrayIndexData = new Variable(arrayIndexName, className, id, valueType, valueObjId, tracePoint, isReturned); + Variable arrayIndexData = new Variable(arrayIndexName, valueClassName, valueId, valueType, valueObjId, before, isReturned); this.addChild(arrayIndexData); } } + public void addAdditionalAttribute(String key, Object value) { + additionalAttributes.put(key, value); + } + + public Object getAdditionalAttribute(String key) { + return additionalAttributes.get(key); + } + private enum DeepHierarchy { NONE, FIELD, ARRAY; } diff --git a/src/org/ntlab/traceDebugger/VariableLabelProvider.java b/src/org/ntlab/traceDebugger/VariableLabelProvider.java index 3607ae2..058d92b 100644 --- a/src/org/ntlab/traceDebugger/VariableLabelProvider.java +++ b/src/org/ntlab/traceDebugger/VariableLabelProvider.java @@ -1,22 +1,40 @@ package org.ntlab.traceDebugger; +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.graphics.Color; import org.eclipse.swt.graphics.Image; import org.eclipse.ui.ISharedImages; import org.eclipse.ui.PlatformUI; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; -public class VariableLabelProvider extends LabelProvider implements ITableLabelProvider { +public class VariableLabelProvider 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 Variable) { - Variable variableData = (Variable)value; + if (value instanceof String) { + String name = (String)value; switch (columnIndex) { case 0: - String variableName = variableData.getVariableName(); + if (name.contains("Constructor")) { + return name.substring(0, name.indexOf("Constructor")); + } + return name.substring(0, name.indexOf(":")); + case 1: + String valueName = name.substring(name.indexOf(":") + 1); + valueName = valueName.substring(valueName.lastIndexOf(" ") + 1); + boolean isConstructor = name.contains("Constructor"); + return getReadableName(valueName, isConstructor); + } + } + if (value instanceof Variable) { + Variable variableData = (Variable)value; + String variableName = variableData.getVariableName(); + switch (columnIndex) { + case 0: if (variableName.contains("[")) { return variableName.substring(variableName.lastIndexOf("[")); } else if (variableName.contains(".")) { @@ -24,8 +42,22 @@ } return variableName; case 1: - return variableData.getClassName() + " (" + "id = " + variableData.getId() + ")"; - } + String simpleName; + String id; + if (variableData.getVariableType().isContainerSide()) { + simpleName = variableData.getContainerClassName(); + id = variableData.getContainerId(); + } else { + simpleName = variableData.getValueClassName(); + id = variableData.getValueId(); + } + simpleName = simpleName.substring(simpleName.lastIndexOf(".") + 1); + if (simpleName.equals(Variable.NULL_VALUE)) { + return simpleName; + } else { + return simpleName + " (" + "id = " + id + ")"; + } + } } } return "�e�X�g�p�e�L�X�g" + columnIndex; @@ -40,4 +72,64 @@ public Image getImage(Object element) { return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); } + + @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 Variable) { + Variable variable = (Variable)value; + Object markerId = variable.getAdditionalAttribute("markerId"); + if (!(markerId instanceof String)) return null; + switch ((String)markerId) { + case DeltaMarkerManager.SRC_SIDE_DELTA_MARKER: + return DeltaMarkerLabelProvider.SETTER_SIDE_LABEL_COLOR; + case DeltaMarkerManager.DST_SIDE_DELTA_MARKER: + return DeltaMarkerLabelProvider.GETTER_SIDE_LABEL_COLOR; + case DeltaMarkerManager.COORDINATOR_DELTA_MARKER: + return DeltaMarkerLabelProvider.COORDINATOR_LABEL_COLOR; + } + } + } + return null; + } + + private String getReadableName(String name, boolean isConstrutor) { + if (!(name.contains("("))) { + String[] splits = name.split("\\."); + if (splits.length < 2) return name; + return splits[splits.length - 2] + "." + splits[splits.length - 1]; + } + StringBuilder sb = new StringBuilder(); + String receiverTypeAndMethodName = name.substring(0, name.indexOf("(")); + String[] receiverTypeAndMethodNameSplits = receiverTypeAndMethodName.split("\\."); + if (receiverTypeAndMethodNameSplits.length < 2) { + sb.append(receiverTypeAndMethodName); + } else { + if (!isConstrutor) { + sb.append(receiverTypeAndMethodNameSplits[receiverTypeAndMethodNameSplits.length - 2]); + sb.append("."); + } + sb.append(receiverTypeAndMethodNameSplits[receiverTypeAndMethodNameSplits.length - 1]); + } + sb.append("("); + String argsName = name.substring(name.indexOf("(") + 1, name.lastIndexOf(")")); + String delimiter = ""; + for (String argName : argsName.split(",")) { + String[] argNameSplits = argName.split("\\."); + if (argNameSplits.length < 1) { + sb.append(delimiter + argName); + } else { + sb.append(delimiter + argNameSplits[argNameSplits.length - 1]); + } + delimiter = ","; + } + sb.append(")"); + return sb.toString(); + } } diff --git a/src/org/ntlab/traceDebugger/VariableView.java b/src/org/ntlab/traceDebugger/VariableView.java index d87ba6a..946d429 100644 --- a/src/org/ntlab/traceDebugger/VariableView.java +++ b/src/org/ntlab/traceDebugger/VariableView.java @@ -1,42 +1,27 @@ package org.ntlab.traceDebugger; +import java.util.ArrayList; import java.util.List; - -import org.eclipse.jface.action.Action; -import org.eclipse.jface.action.IAction; -import org.eclipse.jface.action.IMenuListener; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.IToolBarManager; -import org.eclipse.jface.action.MenuManager; -import org.eclipse.jface.action.Separator; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.ITreeViewerListener; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.TreeExpansionEvent; 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.Menu; import org.eclipse.swt.widgets.Tree; import org.eclipse.swt.widgets.TreeColumn; -import org.eclipse.ui.IViewPart; -import org.eclipse.ui.IWorkbenchActionConstants; -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.TracePoint; -import org.ntlab.traceDebugger.analyzerProvider.AbstractAnalyzer; -import org.ntlab.traceDebugger.analyzerProvider.DeltaExtractionAnalyzer; public class VariableView extends ViewPart { - private TreeViewer viewer; - private IAction deltaAction; - private Variable selectedVariable; - private Variables variables = Variables.getInstance(); + protected TreeViewer viewer; + protected Variable selectedVariable; + protected Variables variables = Variables.getInstance(); public static final String ID = "org.ntlab.traceDebugger.variableView"; public VariableView() { @@ -60,9 +45,9 @@ treeColumns[i] = new TreeColumn(tree, SWT.NULL); treeColumns[i].setText(treeColumnTexts[i]); treeColumns[i].setWidth(treeColumnWidth[i]); - } - viewer.setContentProvider(new TreeNodeContentProvider()); - viewer.setLabelProvider(new VariableLabelProvider()); + } + viewer.setContentProvider(new MyTreeNodeContentProvider()); + viewer.setLabelProvider(new VariableLabelProvider()); viewer.addSelectionChangedListener(new ISelectionChangedListener() { @Override public void selectionChanged(SelectionChangedEvent event) { @@ -72,7 +57,7 @@ Object value = ((TreeNode)element).getValue(); if (value instanceof Variable) { selectedVariable = (Variable)value; - } + } } } }); @@ -81,29 +66,28 @@ public void treeExpanded(TreeExpansionEvent event) { // �c���[���J������Ɏ��s�����B �����ł͊J�����m�[�h����3��̃m�[�h�𐶐����Ēlj�����B Object element = event.getElement(); - if (!(element instanceof TreeNode)) return; - TreeNode expandedNode = (TreeNode)element; + if (!(element instanceof MyTreeNode)) return; + MyTreeNode expandedNode = (MyTreeNode)element; Object value = expandedNode.getValue(); if (!(value instanceof Variable)) return; - TreeNode[] childNodes = expandedNode.getChildren(); + List childNodes = expandedNode.getChildList(); if (childNodes == null) return; - for (TreeNode childNode : childNodes) { - TreeNode[] grandChildNodes = childNode.getChildren(); + for (MyTreeNode childNode : childNodes) { + List grandChildNodes = childNode.getChildList(); if (grandChildNodes == null) continue; - for (TreeNode grandChildNode : grandChildNodes) { + for (MyTreeNode grandChildNode : grandChildNodes) { Variable grandChildVariable = (Variable)grandChildNode.getValue(); grandChildVariable.createNextHierarchyState(); List list = grandChildVariable.getChildren(); - TreeNode[] nodes = new TreeNode[list.size()]; + List nodes = new ArrayList<>(); for (int i = 0; i < list.size(); i++) { - nodes[i] = new TreeNode(list.get(i)); + nodes.add(i, new MyTreeNode(list.get(i))); } - grandChildNode.setChildren(nodes); + grandChildNode.setChildList(nodes); } } - viewer.refresh(); + viewer.refresh(); } - @Override public void treeCollapsed(TreeExpansionEvent event) {} }); @@ -111,74 +95,58 @@ createToolBar(); createMenuBar(); createPopupMenu(); + TraceDebuggerPlugin.setActiveView(ID, this); } @Override public void setFocus() { // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); viewer.getControl().setFocus(); } - private void createActions() { - deltaAction = new Action() { - @Override - public void run() { - AbstractAnalyzer analyzer = TraceDebuggerPlugin.getAnalyzer(); - if (analyzer instanceof DeltaExtractionAnalyzer) { - DeltaExtractionAnalyzer deltaAnalyzer = (DeltaExtractionAnalyzer)analyzer; - deltaAnalyzer.extractDelta(selectedVariable); - } - } - }; - deltaAction.setText("Extract Delta"); - deltaAction.setToolTipText("Extract Delta"); + protected void createActions() { + } - private void createToolBar() { + protected void createToolBar() { IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); } - private void createMenuBar() { + protected void createMenuBar() { IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); } - private void createPopupMenu() { - MenuManager menuMgr = new MenuManager("#PopupMenu"); - menuMgr.setRemoveAllWhenShown(true); - menuMgr.addMenuListener(new IMenuListener() { - @Override - public void menuAboutToShow(IMenuManager manager) { - manager.add(deltaAction); - manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); - } - }); - Menu menu = menuMgr.createContextMenu(viewer.getControl()); - viewer.getControl().setMenu(menu); - getSite().registerContextMenu(menuMgr, viewer); + protected void createPopupMenu() { + } public void reset() { variables.resetData(); - viewer.setInput(variables.getVariablesTreeNodes()); + viewer.setInput(variables.getVariablesTreeNodesList()); viewer.refresh(); - } + } public void updateVariablesByTracePoint(TracePoint tp, boolean isReturned) { - variables.getAllObjectDataByTracePoint(tp, isReturned); - viewer.setInput(variables.getVariablesTreeNodes()); + updateVariablesByTracePoint(tp, isReturned, null); + } + + public void updateVariablesByTracePoint(TracePoint tp, boolean isReturned, TracePoint before) { + updateVariablesByTracePoint(null, tp, isReturned, before); + } + + public void updateVariablesByTracePoint(TracePoint from, TracePoint to, boolean isReturned) { + updateVariablesByTracePoint(from, to, isReturned, null); } -// public void updateVariablesByAlias(Alias alias) { -// variables.getAllObjectDataByAlias(alias); -// viewer.setInput(variables.getVariablesTreeNodesList()); -// } - - private IViewPart getOtherView(String viewId) { - IWorkbenchPage workbenchPage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(); - try { - return workbenchPage.showView(viewId); - } catch (PartInitException e) { - throw new RuntimeException(e); - } + public void updateVariablesByTracePoint(TracePoint from, TracePoint to, boolean isReturned, TracePoint before) { + variables.updateAllObjectDataByTracePoint(from, to, isReturned, before); + viewer.setInput(variables.getVariablesTreeNodesList()); } -} \ No newline at end of file + + public void updateVariablesForDifferential(TracePoint from, TracePoint to, boolean isReturned) { + variables.updateForDifferential(from, to, isReturned); +// viewer.setInput(variables.getVariablesTreeNodes()); + viewer.refresh(); + } +} diff --git a/src/org/ntlab/traceDebugger/VariableViewRelatedDelta.java b/src/org/ntlab/traceDebugger/VariableViewRelatedDelta.java new file mode 100644 index 0000000..7a92308 --- /dev/null +++ b/src/org/ntlab/traceDebugger/VariableViewRelatedDelta.java @@ -0,0 +1,292 @@ +package org.ntlab.traceDebugger; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +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; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.MenuManager; +import org.eclipse.jface.action.Separator; +import org.eclipse.jface.viewers.TreeNode; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Menu; +import org.eclipse.swt.widgets.TreeItem; +import org.eclipse.ui.IWorkbenchActionConstants; +import org.eclipse.ui.IWorkbenchPage; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodInvocation; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; +import org.ntlab.traceDebugger.Variable.VariableType; +import org.ntlab.traceDebugger.analyzerProvider.Alias; +import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager; +import org.ntlab.traceDebugger.analyzerProvider.VariableUpdatePointFinder; + +public class VariableViewRelatedDelta extends VariableView { + protected IAction jumpAction; + private IAction deltaActionForContainerToComponent; + private IAction deltaActionForThisToAnother; + public static final String ID = "org.ntlab.traceDebugger.variableViewRelatedDelta"; + + public VariableViewRelatedDelta() { + // TODO Auto-generated constructor stub + System.out.println("VariableViewRelatedDelta�N���X���������ꂽ��!"); + } + + @Override + public void createPartControl(Composite parent) { + // TODO Auto-generated method stub + System.out.println("VariableViewRelatedDelta#createPartControl(Composite)���Ă΂ꂽ��!"); + super.createPartControl(parent); + TraceDebuggerPlugin.setActiveView(ID, this); + } + + @Override + public void setFocus() { + // TODO Auto-generated method stub + TraceDebuggerPlugin.setActiveView(ID, this); + viewer.getControl().setFocus(); + } + + @Override + protected void createActions() { + super.createActions(); + jumpAction = new Action() { + public void run() { + TracePoint tp = null; + TracePoint before = DebuggingController.getInstance().getCurrentTp(); + VariableType variableType = selectedVariable.getVariableType(); + if (variableType.equals(VariableType.USE_VALUE)) { + String containerId = selectedVariable.getContainerId(); + String fieldName = selectedVariable.getFullyQualifiedVariableName(); + tp = VariableUpdatePointFinder.getInstance().getPoint(containerId, fieldName, before); + } else if (variableType.equals(VariableType.USE_RETURN)) { + String receiverId = selectedVariable.getContainerId(); + String valueId = selectedVariable.getValueId(); + String receiverClassName = selectedVariable.getContainerClassName(); + VariableUpdatePointFinder finder = VariableUpdatePointFinder.getInstance(); + if (receiverClassName.contains("Iterator") || receiverClassName.contains("Itr") + || receiverClassName.contains("Collections$UnmodifiableCollection$1")) { + tp = finder.getIteratorPoint(receiverId); + if (tp == null) return; + MethodInvocation mi = ((MethodInvocation)tp.getStatement()); + receiverId = mi.getCalledMethodExecution().getThisObjId(); + } + tp = finder.getDefinitionInvocationPoint(receiverId, valueId, before); + } + if (tp == null) return; + DebuggingController controller = DebuggingController.getInstance(); + controller.jumpToTheTracePoint(tp, false); + } + }; + jumpAction.setText("Jump to Definition"); + jumpAction.setToolTipText("Jump to Definition"); + + deltaActionForContainerToComponent = new Action() { + @Override + public void run() { + DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.createNewView(DeltaMarkerView.ID, IWorkbenchPage.VIEW_ACTIVATE); + newDeltaMarkerView.extractDeltaForContainerToComponent(selectedVariable); + } + }; + deltaActionForContainerToComponent.setText("Extract Delta"); + deltaActionForContainerToComponent.setToolTipText("Extract Delta"); + + deltaActionForThisToAnother = new Action() { + @Override + public void run() { + TracePoint before = selectedVariable.getBeforeTracePoint(); + String thisId = before.getMethodExecution().getThisObjId(); + String thisClassName = before.getMethodExecution().getThisClassName(); + String anotherId; + String anotherClassName; + if (selectedVariable.getVariableType().isContainerSide()) { + anotherId = selectedVariable.getContainerId(); + anotherClassName = selectedVariable.getContainerClassName(); + } else { + anotherId = selectedVariable.getValueId(); + anotherClassName = selectedVariable.getValueClassName(); + } + DeltaMarkerView newDeltaMarkerView = (DeltaMarkerView)TraceDebuggerPlugin.createNewView(DeltaMarkerView.ID, IWorkbenchPage.VIEW_ACTIVATE); + newDeltaMarkerView.extractDeltaForThisToAnother(thisId, thisClassName, anotherId, anotherClassName, before); + } + }; + deltaActionForThisToAnother.setText("Extract Delta"); + deltaActionForThisToAnother.setToolTipText("Extract Delta"); + } + + @Override + protected void createPopupMenu() { + MenuManager menuMgr = new MenuManager("#PopupMenu"); + menuMgr.setRemoveAllWhenShown(true); + menuMgr.addMenuListener(new IMenuListener() { + @Override + public void menuAboutToShow(IMenuManager manager) { + // �E�N���b�N����x�ɌĂяo����� + VariableType variableType = selectedVariable.getVariableType(); + if (variableType.equals(VariableType.USE_VALUE)) { + manager.add(jumpAction); + jumpAction.setText("Jump to Definition"); + jumpAction.setToolTipText("Jump to Definition"); + } else if (variableType.equals(VariableType.USE_RETURN)) { + manager.add(jumpAction); + if (updateDeltaActionForThisToAnotherTexts(selectedVariable)) { + manager.add(deltaActionForThisToAnother); + } + jumpAction.setText("Jump to Addition"); + jumpAction.setToolTipText("Jump to Addition"); + } else if (variableType.isDef()) { + if (updateDeltaActionForContainerToComponentTexts(selectedVariable)) { + manager.add(deltaActionForContainerToComponent); + } + if (updateDeltaActionForThisToAnotherTexts(selectedVariable)) { + String text1 = deltaActionForThisToAnother.getText(); + String text2 = deltaActionForContainerToComponent.getText(); + if (!(text1.equals(text2))) { + manager.add(deltaActionForThisToAnother); + } + } + } else if (variableType.equals(VariableType.PARAMETER)) { + if (updateDeltaActionForThisToAnotherTexts(selectedVariable)) { + manager.add(deltaActionForThisToAnother); + } + } + manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); + } + }); + Menu menu = menuMgr.createContextMenu(viewer.getControl()); + viewer.getControl().setMenu(menu); + getSite().registerContextMenu(menuMgr, viewer); + } + + private boolean updateDeltaActionForContainerToComponentTexts(Variable variable) { + String valueId = selectedVariable.getValueId(); + String valueClassName = selectedVariable.getValueClassName(); + valueClassName = valueClassName.substring(valueClassName.lastIndexOf(".") + 1); + if (!(valueId.isEmpty()) && !(valueClassName.isEmpty())) { + String containerId = selectedVariable.getContainerId(); + String containerClassName = selectedVariable.getContainerClassName(); + if (containerId != null && containerClassName != null) { + containerClassName = containerClassName.substring(containerClassName.lastIndexOf(".") + 1); + String textForContainerToComponent = String.format("Extract Delta [ %s (id = %s) -> %s (id = %s) ]", containerClassName, containerId, valueClassName, valueId); + deltaActionForContainerToComponent.setText(textForContainerToComponent); + deltaActionForContainerToComponent.setToolTipText(textForContainerToComponent); + return true; + } + } + deltaActionForContainerToComponent.setText(""); + deltaActionForContainerToComponent.setToolTipText(""); + return false; + +// String containerId = selectedVariable.getContainerId(); +// String containerClassName = selectedVariable.getContainerClassName(); +// if (containerId != null && containerClassName != null) { +// containerClassName = containerClassName.substring(containerClassName.lastIndexOf(".") + 1); +// String textForContainerToComponent = String.format("Extract Delta [ %s (id = %s) -> %s (id = %s) ]", containerClassName, containerId, valueClassName, valueId); +// deltaActionForContainerToComponent.setText(textForContainerToComponent); +// deltaActionForContainerToComponent.setToolTipText(textForContainerToComponent); +// return true; +// } else { +// deltaActionForContainerToComponent.setText(""); +// deltaActionForContainerToComponent.setToolTipText(""); +// return false; +// } + } + + private boolean updateDeltaActionForThisToAnotherTexts(Variable variable) { + VariableType variableType = variable.getVariableType(); + String anotherId; + String anotherClassName; + if (variableType.isContainerSide()) { + anotherId = selectedVariable.getContainerId(); + anotherClassName = selectedVariable.getContainerClassName(); + } else { + anotherId = selectedVariable.getValueId(); + anotherClassName = selectedVariable.getValueClassName(); + } + anotherClassName = anotherClassName.substring(anotherClassName.lastIndexOf(".") + 1); + TracePoint before = selectedVariable.getBeforeTracePoint(); + String thisId = before.getMethodExecution().getThisObjId(); + String thisClassName = before.getMethodExecution().getThisClassName(); + if (thisId != null && thisClassName != null) { + thisClassName = thisClassName.substring(thisClassName.lastIndexOf(".") + 1); + String textForThisToAnother = String.format("Extract Delta [ %s (id = %s) -> %s (id = %s) ]", thisClassName, thisId, anotherClassName, anotherId); + deltaActionForThisToAnother.setText(textForThisToAnother); + deltaActionForThisToAnother.setToolTipText(textForThisToAnother); + return true; + } else { + deltaActionForThisToAnother.setText(""); + deltaActionForThisToAnother.setToolTipText(""); + return false; + } + } + + public void markAndExpandVariablesByDeltaMarkers(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); + if (srcSideDeltaMarkers != null) { + markVariables(DeltaMarkerManager.SRC_SIDE_DELTA_MARKER, srcSideDeltaMarkers); + } + if (dstSideDeltaMarkers != null) { + markVariables(DeltaMarkerManager.DST_SIDE_DELTA_MARKER, dstSideDeltaMarkers); + } + if (coordinatorMarker != null) { + 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(DeltaMarkerManager.DELTA_MARKER_ATR_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; + collectNodes((TreeNode)obj, expandedNodes); + } + viewer.setExpandedElements(expandedNodes.toArray(new Object[expandedNodes.size()])); + } + + private void collectNodes(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) { + collectNodes(child, expandedNodes); + } + } +} diff --git a/src/org/ntlab/traceDebugger/Variables.java b/src/org/ntlab/traceDebugger/Variables.java index 211ba3e..e9ae236 100644 --- a/src/org/ntlab/traceDebugger/Variables.java +++ b/src/org/ntlab/traceDebugger/Variables.java @@ -1,105 +1,102 @@ package org.ntlab.traceDebugger; import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; import java.util.List; +import java.util.Map; +import java.util.Set; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.JavaModelException; -import org.eclipse.jface.viewers.TreeNode; +import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayUpdate; +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.ObjectReference; import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; +import org.ntlab.traceDebugger.Variable.VariableType; 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<>(); + private List rootTreeNodes = new ArrayList<>(); + private Map> containerIdToDifferentialUpdateTracePoints = new HashMap<>(); // �ϐ������X�V�ӏ����L�� + public static final String VARIABLE_TYPE_KEY = "variableType"; + public static Variables getInstance() { return theInstance; } - public TreeNode[] getVariablesTreeNodes() { - TreeNode[] roots = new TreeNode[allObjData.size()]; - if (allObjData.isEmpty()) { - return roots; - } - for (int i = 0; i < allObjData.size(); i++) { - Variable rootVariableData = allObjData.get(i); - createVariablesTreeNode(null, roots, i, rootVariableData); - } - return roots; + public List getVariablesTreeNodesList() { + return rootTreeNodes; } - private void createVariablesTreeNode(TreeNode parentNode, TreeNode[] addingNodes, int index, Variable addingVariableData) { - TreeNode newNode = new TreeNode(addingVariableData); + private void createVariablesTreeNodeList(MyTreeNode parentNode, List addingNodes, int index, Variable addingVariableData) { + MyTreeNode newNode = new MyTreeNode(addingVariableData); newNode.setParent(parentNode); - addingNodes[index] = newNode; - TreeNode[] childNodes = new TreeNode[addingVariableData.getChildren().size()]; - addingNodes[index].setChildren(childNodes); + addingNodes.add(index, newNode); + List childNodes = new ArrayList<>(); + addingNodes.get(index).setChildList(childNodes); for (int i = 0; i < addingVariableData.getChildren().size(); i++) { Variable child = addingVariableData.getChildren().get(i); - createVariablesTreeNode(newNode, childNodes, i, child); + createVariablesTreeNodeList(newNode, childNodes, i, child); } } - - 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; - } - - public List getAllObjectDataByTracePoint(TracePoint tp, boolean isReturned) { - MethodExecution methodExecution = tp.getMethodExecution(); - getAllObjectData(methodExecution, tp, isReturned); - return allObjData; - } - - public void resetData() { - rootThisObjData = null; - argsData.clear(); - allObjData.clear(); - } - - private void getAllObjectData(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); - } - } - - private void getRootThisState(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(); + updateAllObjectData(null, tp, false, null); } - private void getArgsState(MethodExecution methodExecution, TracePoint tp, boolean isReturned) { + public void updateAllObjectDataByTracePoint(TracePoint from, TracePoint to, boolean isReturned, TracePoint before) { + updateAllObjectData(from, to, isReturned, before); + } + + private void updateAllObjectData(TracePoint from, TracePoint to, boolean isReturned, TracePoint before) { + resetData(); + MethodExecution me = to.getMethodExecution(); + updateRootThisState(me, to, isReturned, before); + updateArgsState(me, to, isReturned, before); + for (int i = 0; i < roots.size(); i++) { + Variable rootVariableData = roots.get(i); + createVariablesTreeNodeList(null, rootTreeNodes, i, rootVariableData); + } + createSpecialVariables(from, to, isReturned); + } + + private void updateRootThisState(MethodExecution methodExecution, TracePoint tp, boolean isReturned, TracePoint before) { + String thisObjId = methodExecution.getThisObjId(); + String thisClassName = methodExecution.getThisClassName(); + if (before == null) before = tp; + Variable variable = new Variable("this", null, null, thisClassName, thisObjId, before, isReturned); + roots.add(variable); + variable.createNextHierarchyState(); + } + + private void updateArgsState(MethodExecution methodExecution, TracePoint tp, boolean isReturned, TracePoint before) { // methodExecution������arguments���擾(ArrayList)���A����arguments�̃T�C�Y���擾(int) List args = methodExecution.getArguments(); + if (before == null) before = tp; if (args.size() > 0) { - IType type = JavaEditorOperator.findIType(methodExecution); + IType type = JavaElementFinder.findIType(methodExecution); String methodSignature = methodExecution.getSignature(); - IMethod method = JavaEditorOperator.findIMethod(type, methodSignature); + IMethod method = JavaElementFinder.findIMethod(type, methodSignature); String[] argNames = getParameterNames(method); // ������IMethod���牼���������擾���� for (int i = 0; i < args.size(); i++) { String argName = (argNames.length == args.size()) ? argNames[i] : "arg" + i; // ���Ȃ��Ƃ������̌����s��v�̂Ƃ��͐����������������Ă��Ȃ� ObjectReference arg = args.get(i); String argId = arg.getId(); String argType = arg.getActualType(); - Variable argData = new Variable(argName, null, null, argType, argId, tp, isReturned); + Variable argData = new Variable(argName, null, null, argType, argId, before, isReturned, VariableType.PARAMETER); argData.createNextHierarchyState(); - argsData.add(argData); + roots.add(argData); } } } @@ -114,5 +111,250 @@ } } 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; + VariableType variableType = variable.getVariableType(); + String id = variableType.isContainerSide() ? variable.getContainerId() : variable.getValueId(); + if (id.equals("0")) return; + if (idSet.contains(id)) { + for (Map.Entry entry : additionalAttributes.entrySet()) { + variable.addAdditionalAttribute(entry.getKey(), entry.getValue()); + } + } + for (Variable child : variable.getChildren()) { + addAdditionalAttributes(child, idSet, additionalAttributes); + } + } + + public void addDifferentialUpdatePoint(TracePoint tp) { + Statement statement = tp.getStatement(); + String containerId = null; + if (statement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)statement; + containerId = fu.getContainerObjId(); + } else if (statement instanceof ArrayUpdate) { + ArrayUpdate au = (ArrayUpdate)statement; + containerId = au.getArrayObjectId(); + } + if (containerId == null) return; + List tracePoints = containerIdToDifferentialUpdateTracePoints.get(containerId); + if (tracePoints == null) { + tracePoints = new ArrayList(); + containerIdToDifferentialUpdateTracePoints.put(containerId, tracePoints); + } + tracePoints.add(tp.duplicate()); + } + + public void updateForDifferential(TracePoint from, TracePoint to, boolean isReturned) { + updateForDifferential(); + resetSpecialValues(); + createSpecialVariables(from, to, isReturned); + } + + private void updateForDifferential() { + for (Variable variable : roots) { + updateForDifferential(variable, new HashSet()); + } + containerIdToDifferentialUpdateTracePoints.clear(); + } + + private void updateForDifferential(Variable variable, Set hasCheckedObjectIdSet) { + Set containerIdList = containerIdToDifferentialUpdateTracePoints.keySet(); + String containerId = variable.getContainerId(); + if (containerIdList.contains(containerId)) { + for (TracePoint tp : containerIdToDifferentialUpdateTracePoints.get(containerId)) { + Statement statement = tp.getStatement(); + if (statement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)statement; + if (variable.getFullyQualifiedVariableName().equals(fu.getFieldName())) { + updateForDifferentialField(variable, fu.getValueClassName(), fu.getValueObjId(), tp); + } + } else if (statement instanceof ArrayUpdate) { + ArrayUpdate au = (ArrayUpdate)statement; + String fullyQualifiedVariableName = variable.getFullyQualifiedVariableName(); + if (fullyQualifiedVariableName.contains("[" + au.getIndex() + "]")) { + updateForDifferentialField(variable, au.getValueClassName(), au.getValueObjectId(), tp); + } + } + } + } + HashSet hasCheckedObjectIdSetOnNext = new HashSet<>(hasCheckedObjectIdSet); + hasCheckedObjectIdSetOnNext.add(variable.getContainerId()); + for (Variable child : variable.getChildren()) { + if (hasCheckedObjectIdSetOnNext.contains(child.getContainerId())) continue; + updateForDifferential(child, hasCheckedObjectIdSetOnNext); + } + } + + private void updateForDifferentialField(Variable variable, String valueClassName, String valueId, TracePoint lastUpdatePoint) { + variable.update(valueClassName, valueId, lastUpdatePoint, false); + variable.createNextHierarchyState(); + MyTreeNode node = getTreeNodeFor(variable, rootTreeNodes); + List childList = node.getChildList(); + childList.clear(); + for (int i = 0; i < variable.getChildren().size(); i++) { + Variable childVariable = variable.getChildren().get(i); + createVariablesTreeNodeList(node, childList, i, childVariable); + } + } + + private void createSpecialVariables(TracePoint from, TracePoint to, boolean isReturned) { +// List list = new ArrayList<>(); + List specialVariablesOfUseSide = new ArrayList<>(); + List specialVariablesDefSide = new ArrayList<>(); + String parentNodeNameOfUseSide = null; + String parentNodeNameOfDefSide = null; + if (from != null) { + // ���s�����use�v�f + Statement fromStatement = from.getStatement(); + if (fromStatement instanceof FieldAccess) { + FieldAccess fa = (FieldAccess)fromStatement; + String containerClassName = fa.getContainerClassName(); + String containerObjId = fa.getContainerObjId(); + String valueClassName = fa.getValueClassName(); + String valueObjId = fa.getValueObjId(); + Variable container = new Variable(Variable.CONTAINER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_CONTAINER); + Variable value = new Variable(Variable.VALUE_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_VALUE); + specialVariablesOfUseSide.add(container); + specialVariablesOfUseSide.add(value); + parentNodeNameOfUseSide = "after field get of:" + fa.getFieldName(); + } else if (fromStatement instanceof MethodInvocation) { + MethodInvocation mi = (MethodInvocation)fromStatement; + MethodExecution calledME = mi.getCalledMethodExecution(); + ObjectReference returnValue = calledME.getReturnValue(); + if (returnValue != null) { + String containerClassName = calledME.getThisClassName(); + String containerObjId = calledME.getThisObjId(); + String valueClassName = returnValue.getActualType(); + String valueObjId = returnValue.getId(); + Variable receiver = new Variable(Variable.RECEIVER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_RECEIVER); + Variable returned = new Variable(Variable.RETURN_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, from, isReturned, VariableType.USE_RETURN); + specialVariablesOfUseSide.add(receiver); + specialVariablesOfUseSide.add(returned); + if (calledME.isConstructor()) { + parentNodeNameOfUseSide = "after invocation of Constructor:" + calledME.getSignature(); + } else { + parentNodeNameOfUseSide = "after invocation of:" + calledME.getSignature(); + } + } + } + } + + if (to != null) { + // ���s���O��def�v�f + Statement toStatement = to.getStatement(); + if (toStatement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)toStatement; + String containerClassName = fu.getContainerClassName(); + String containerObjId = fu.getContainerObjId(); + String valueClassName = fu.getValueClassName(); + String valueObjId = fu.getValueObjId(); + Variable container = new Variable(Variable.CONTAINER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_CONTAINER); + Variable value = new Variable(Variable.VALUE_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_VALUE); + specialVariablesDefSide.add(container); + specialVariablesDefSide.add(value); + parentNodeNameOfDefSide = "before field set of:" + fu.getFieldName(); + } else if (toStatement instanceof MethodInvocation) { + MethodInvocation mi = (MethodInvocation)toStatement; + MethodExecution calledME = mi.getCalledMethodExecution(); + List args = calledME.getArguments(); + String valueClassName = ""; + String valueObjId = ""; + if (args.size() > 0) { + valueClassName = args.get(0).getActualType(); + valueObjId = args.get(0).getId(); + } + String containerClassName = calledME.getThisClassName(); + String containerObjId = calledME.getThisObjId(); + Variable receiver = new Variable(Variable.RECEIVER_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_RECEIVER); + specialVariablesDefSide.add(receiver); + for (ObjectReference obj : args) { + valueClassName = obj.getActualType(); + valueObjId = obj.getId(); + Variable arg = new Variable(Variable.ARG_VARIABLE_NAME, containerClassName, containerObjId, valueClassName, valueObjId, to, isReturned, VariableType.DEF_ARG); + specialVariablesDefSide.add(arg); + } + if (calledME.isConstructor()) { + parentNodeNameOfDefSide = "before invocation of Constructor:" + calledME.getSignature(); + } else { + parentNodeNameOfDefSide = "before invocation of:" + calledME.getSignature(); + } + } + } + if (parentNodeNameOfUseSide != null) { + setSpecialVariableNodes(parentNodeNameOfUseSide, specialVariablesOfUseSide); + } + if (parentNodeNameOfDefSide != null) { + setSpecialVariableNodes(parentNodeNameOfDefSide, specialVariablesDefSide); + } + } + + private void setSpecialVariableNodes(String parentNodeName, List specialVariables) { + MyTreeNode parentNode = new MyTreeNode(parentNodeName); + rootTreeNodes.add(0, parentNode); + MyTreeNode[] children = new MyTreeNode[specialVariables.size()]; + for (int i = 0; i < specialVariables.size(); i++) { + Variable variable = specialVariables.get(i); + variable.createNextHierarchyState(); + roots.add(0, variable); + MyTreeNode variableNode = new MyTreeNode(variable); + children[i] = variableNode; + variableNode.setParent(parentNode); + createChildNodesOfSpecialVariableNode(variableNode); + } + parentNode.setChildren(children); + } + + private void createChildNodesOfSpecialVariableNode(MyTreeNode variableNode) { + List childList = new ArrayList<>(); + variableNode.setChildList(childList); + Variable variable = (Variable)variableNode.getValue(); + for (int i = 0; i < variable.getChildren().size(); i++) { + Variable childVariable = variable.getChildren().get(i); + createVariablesTreeNodeList(variableNode, childList, i, childVariable); + } + } + + public void resetData() { + roots.clear(); + rootTreeNodes.clear(); + containerIdToDifferentialUpdateTracePoints.clear(); + } + + private void resetSpecialValues() { + for (int i = roots.size() - 1; i >= 0; i--) { + Variable root = roots.get(i); + String variableName = root.getVariableName(); + if (variableName.equals(Variable.CONTAINER_VARIABLE_NAME) + || variableName.equals(Variable.VALUE_VARIABLE_NAME) + || variableName.equals(Variable.RECEIVER_VARIABLE_NAME) + || variableName.equals(Variable.ARG_VARIABLE_NAME) + || variableName.equals(Variable.RETURN_VARIABLE_NAME)) { + roots.remove(i); + } + } + for (int i = rootTreeNodes.size() - 1; i >= 0; i--) { + MyTreeNode node = rootTreeNodes.get(i); + if (node.getValue() instanceof String) { + rootTreeNodes.remove(i); + } + } + } + + private MyTreeNode getTreeNodeFor(Variable variable, List nodes) { + for (MyTreeNode node : nodes) { + if (node.getValue().equals(variable)) return node; + MyTreeNode deep = getTreeNodeFor(variable, node.getChildList()); + if (deep != null) return deep; + } + return null; + } } diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/Alias.java b/src/org/ntlab/traceDebugger/analyzerProvider/Alias.java index 370f2e7..0ff8e1a 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/Alias.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/Alias.java @@ -1,19 +1,13 @@ package org.ntlab.traceDebugger.analyzerProvider; -import java.util.ArrayList; - import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayAccess; import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayCreate; -import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayUpdate; 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.ObjectReference; import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; -import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; - + /** * �I�u�W�F�N�g�̎Q�Ə��(�G�C���A�X)��\���N���X * @author Isitani @@ -22,219 +16,142 @@ public class Alias { private String objectId; private TracePoint occurrencePoint; // ���Y�I�u�W�F�N�g�̎Q�Ƃ��s���Ă�����s�ӏ��ɑΉ�����TracePoint - /** - * ���Y�I�u�W�F�N�g�̎Q�Ƃ�TracePoint�ɂ����Ăǂ��Ɍ���Ă��邩��\��
- * 0 �t�B�[���h�A�N�Z�X���̃R���e�i �������� ���\�b�h�Ăяo�����̃��V�[�o
- * 1, 2, 3 �c�c n �t�B�[���h�A�N�Z�X���̃t�B�[���h(1) �������� ���\�b�h�Ăяo������n�Ԗڂ̎����� (1���珇�Ԃ�)
- * -1 ���\�b�h�Ăяo�����̖߂�l
- *
- * ��1: d = a.m(b, c);
- *
- * ��1�̎��s���ɂ�����, a�̓��\�b�h�Ăяo���̃��V�[�o�Ȃ̂�0, b�̓��\�b�h�Ăяo����1�Ԗڂ̎������Ȃ̂�1,
- * c�̓��\�b�h�Ăяo����2�Ԗڂ̎������Ȃ̂�2, a.m(b, c)�̖߂�l��-1 �ƂȂ�.
- *
- * ��2: d = a.f;
- * ��2�̎��s���ɂ�����, a�̓t�B�[���h�̃R���e�i�Ȃ̂�0, b�̓t�B�[���h�Ȃ̂�1 �ƂȂ�. - * - */ - private int occurrenceExp; - public static final int OCCURRENCE_EXP_CONTAINER = 0; - public static final int OCCURRENCE_EXP_RECEIVER = 0; - public static final int OCCURRENCE_EXP_FIELD = 1; - public static final int OCCURRENCE_EXP_ARRAY = 1; - public static final int OCCURRENCE_EXP_FIRST_ARG = 1; - public static final int OCCURRENCE_EXP_RETURN = -1; + private AliasType aliasType; + private int index; - private static final String FIELD_ACCESS = "Field Access"; - private static final String FIELD_UPDATE = "Field Update"; - private static final String ARRAY_ACCESS = "Array Access"; - private static final String ARRAY_UPDATE = "Array Update"; - private static final String ARRAY_CREATE = "Array Create"; - private static final String METHOD_INVOCATION = "Method Invocation"; - private static final String CREATION = "Creation"; + public enum AliasType { + // ���\�b�h�ւ̓��� + FORMAL_PARAMETER, + THIS, + METHOD_INVOCATION, + CONSTRACTOR_INVOCATION, + + // �ǐՃI�u�W�F�N�g�̐؂�ւ� + FIELD, + CONTAINER, + ARRAY_ELEMENT, + ARRAY, + ARRAY_CREATE, - public Alias(String objectId, TracePoint occurrencePoint, int occurrenceExp) { + // ���\�b�h����̏o�� + ACTUAL_ARGUMENT, + RECEIVER, + RETURN_VALUE + } + + public Alias(AliasType aliasType, int index, String objectId, TracePoint occurrencePoint) { + this.aliasType = aliasType; + this.index = index; this.objectId = objectId; this.occurrencePoint = occurrencePoint; - this.occurrenceExp = occurrenceExp; + } + + public AliasType getAliasType() { + return aliasType; + } + + public int getIndex() { + return index; } public String getObjectId() { return objectId; } - + public TracePoint getOccurrencePoint() { return occurrencePoint; } - - public int getOccurrenceExp() { - return occurrenceExp; - } public MethodExecution getMethodExecution() { return occurrencePoint.getMethodExecution(); } - public String getMethodExecutionClassName() { - MethodExecution methodExecution = occurrencePoint.getMethodExecution(); - return Trace.getDeclaringType(methodExecution.getSignature(), methodExecution.isConstructor()); - } - - public String getSourceFileName() { - String methodExecutionClassName = getMethodExecutionClassName(); - methodExecutionClassName = methodExecutionClassName.replace(".", ""); - return methodExecutionClassName + ".java"; - } - public String getMethodSignature() { - return occurrencePoint.getMethodExecution().getCallerSideSignature(); + String signature = occurrencePoint.getMethodExecution().getCallerSideSignature(); + if (signature != null) return signature; + return occurrencePoint.getMethodExecution().getSignature(); +// return occurrencePoint.getMethodExecution().getCallerSideSignature(); } public int getLineNo() { - Statement statement = occurrencePoint.getStatement(); - return statement.getLineNo(); - } - - public String getStatementType() { - Statement statement = occurrencePoint.getStatement(); - String statementType = ""; - if (statement instanceof FieldAccess) { - statementType = FIELD_ACCESS; - } else if (statement instanceof FieldUpdate) { - statementType = FIELD_UPDATE; - } else if (statement instanceof ArrayAccess) { - statementType = ARRAY_ACCESS; - } else if (statement instanceof ArrayUpdate) { - statementType = ARRAY_UPDATE; - } else if (statement instanceof ArrayCreate) { - statementType = ARRAY_CREATE; - } else if (statement instanceof MethodInvocation) { - MethodInvocation mi = (MethodInvocation)statement; - if (mi.getCalledMethodExecution().isConstructor()) { - statementType = CREATION; - } else { - statementType = METHOD_INVOCATION; - } + try { + Statement statement = occurrencePoint.getStatement(); + return statement.getLineNo(); + } catch (Exception e) { + return -1; } - return statementType; } - public String getStatementSignature() { - Statement statement = occurrencePoint.getStatement(); - String statementSignature = ""; - if (statement instanceof FieldAccess) { - FieldAccess fa = (FieldAccess)statement; - statementSignature = fa.getFieldName(); - } else if (statement instanceof FieldUpdate) { - FieldUpdate fu = (FieldUpdate)statement; - statementSignature = fu.getFieldName(); - } else if (statement instanceof ArrayAccess) { - ArrayAccess aa = (ArrayAccess)statement; - statementSignature = aa.getArrayClassName() + "[" + aa.getIndex() + "]"; - } else if (statement instanceof ArrayUpdate) { - ArrayUpdate au = (ArrayUpdate)statement; - statementSignature = au.getArrayClassName() + "[" + au.getIndex() + "]"; - } else if (statement instanceof ArrayCreate) { - ArrayCreate ac = (ArrayCreate)statement; - statementSignature = ac.getArrayClassName(); - } else if (statement instanceof MethodInvocation) { - MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); - statementSignature = me.getCallerSideSignature(); - } - return statementSignature; + public void setIndex(int index) { + this.index = index; } - public String getClassName() { + public String getObjectType() { + TracePoint tmpTp; + Statement callerStatement; Statement statement = occurrencePoint.getStatement(); - String className = ""; - if (statement instanceof FieldAccess) { - if (occurrenceExp == OCCURRENCE_EXP_CONTAINER) { - className = ((FieldAccess) statement).getContainerClassName(); - } else if (occurrenceExp == OCCURRENCE_EXP_FIELD) { - className = ((FieldAccess) statement).getValueClassName(); + switch (aliasType) { + // ���\�b�h�ւ̓��� + case FORMAL_PARAMETER: + tmpTp = occurrencePoint.duplicate(); + tmpTp.stepBackOver(); + callerStatement = tmpTp.getStatement(); + if (callerStatement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)callerStatement).getCalledMethodExecution(); + return me.getArguments().get(index).getActualType(); } - } else if (statement instanceof FieldUpdate) { - if (occurrenceExp == OCCURRENCE_EXP_CONTAINER) { - className = ((FieldUpdate) statement).getContainerClassName(); - } else if (occurrenceExp == OCCURRENCE_EXP_FIELD) { - className = ((FieldUpdate) statement).getValueClassName(); + case THIS: + if (statement instanceof FieldAccess) { + return ((FieldAccess)statement).getContainerClassName(); } - } else if (statement instanceof ArrayAccess) { - className = ((ArrayAccess) statement).getValueClassName(); - } else if (statement instanceof ArrayUpdate) { - className = ((ArrayUpdate) statement).getValueClassName(); - } else if (statement instanceof ArrayCreate) { - className = ((ArrayCreate) statement).getArrayClassName(); - } else if (statement instanceof MethodInvocation) { - MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); - if (occurrenceExp == OCCURRENCE_EXP_RETURN) { - className = me.getReturnValue().getActualType(); - } else if (occurrenceExp == OCCURRENCE_EXP_RECEIVER) { - className = me.getThisClassName(); - } else { - int index = occurrenceExp - OCCURRENCE_EXP_FIRST_ARG; - ArrayList args = me.getArguments(); - if (index >= 0 && index < args.size()) { - className = me.getArguments().get(index).getActualType(); - } - } - } - return className; - } - - public String getOccurrenceText() { - String statementType = getStatementType(); - switch (statementType) { - case FIELD_ACCESS: - case FIELD_UPDATE: - return (occurrenceExp == OCCURRENCE_EXP_CONTAINER) ? "Container" : "Field"; - case ARRAY_ACCESS: - case ARRAY_UPDATE: - return (occurrenceExp == OCCURRENCE_EXP_CONTAINER) ? "Array Object" : "Array Value"; - case ARRAY_CREATE: - return "New Array"; case METHOD_INVOCATION: - if (occurrenceExp <= 0) { - return (occurrenceExp == OCCURRENCE_EXP_RECEIVER) ? "Receiver" : "Return Value"; + case CONSTRACTOR_INVOCATION: + if (statement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); + return me.getReturnValue().getActualType(); } - final String[] ORDER_TEXT = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th", "th", "th", "th", "th"}; // 0-13�ɑΉ� - if (occurrenceExp % 100 >= ORDER_TEXT.length) { - return occurrenceExp + ORDER_TEXT[occurrenceExp % 10] + " arg"; // ��2����14�ȏ�Ȃ�, ��1���̐����ɑΉ������� - } else if (occurrenceExp % 100 >= 0) { - return occurrenceExp + ORDER_TEXT[occurrenceExp % 100] + " arg"; // ��2����0�ȏ�13�ȉ��Ȃ�, ��2���̐����ɑΉ������� + // �ǐՃI�u�W�F�N�g�̐؂�ւ� + case FIELD: + if (statement instanceof FieldAccess) { + return ((FieldAccess)statement).getValueClassName(); } - case CREATION: - return "New Object"; + case CONTAINER: + if (statement instanceof FieldAccess) { + return ((FieldAccess)statement).getContainerClassName(); + } + case ARRAY_ELEMENT: + if (statement instanceof ArrayAccess) { + return ((ArrayAccess)statement).getValueClassName(); + } + case ARRAY: + if (statement instanceof ArrayAccess) { + return ((ArrayAccess)statement).getArrayClassName(); + } + case ARRAY_CREATE: + if (statement instanceof ArrayCreate) { + return ((ArrayCreate)statement).getArrayClassName(); + } + + // ���\�b�h����̏o�� + case ACTUAL_ARGUMENT: + if (statement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); + return me.getArguments().get(index).getActualType(); + } + case RECEIVER: + if (statement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); + return me.getThisClassName(); + } + case RETURN_VALUE: + tmpTp = occurrencePoint.duplicate(); + tmpTp.stepOver(); + callerStatement = tmpTp.getStatement(); + if (callerStatement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)callerStatement).getCalledMethodExecution(); + return me.getReturnValue().getActualType(); + } } - return String.valueOf(occurrenceExp); - } - - public boolean isOrigin() { - Statement statement = occurrencePoint.getStatement(); - if (statement instanceof MethodInvocation) { - MethodExecution calledMethodExecution = ((MethodInvocation)statement).getCalledMethodExecution(); - return calledMethodExecution.isConstructor(); - } else if (statement instanceof ArrayCreate) { - return true; - } - return false; - } - - @Override - public String toString() { - Statement statement = occurrencePoint.getStatement(); - String className = getClassName(); - String methodSignature = getMethodSignature(); - String statementType = getStatementType(); - String statementSigunarure = getStatementSignature(); - String indent = " "; - StringBuilder str = new StringBuilder(); - str.append("objId: " + objectId + " (class = " + className + ")" + "\n"); - str.append("tp: " + occurrencePoint + "\n"); - str.append(indent + "signature: " + methodSignature + "\n"); - str.append(indent + "lineNo: " + statement.getLineNo() + "\n"); - str.append(indent + "statementType: " + statementType + " -> " + statementSigunarure + "\n"); - str.append("occurrenceExp: " + occurrenceExp + "\n"); - return str.toString(); + return ""; } } \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java index 0621515..1be49c6 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.java @@ -1,163 +1,109 @@ package org.ntlab.traceDebugger.analyzerProvider; -import java.util.ArrayList; -import java.util.Collections; import java.util.List; +import java.util.Map; +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.ObjectReference; import org.ntlab.traceAnalysisPlatform.tracer.trace.Reference; import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; 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.Variable; public class DeltaExtractionAnalyzer extends AbstractAnalyzer { - private static DeltaExtractionAnalyzer getInstance = null; + private static DeltaExtractionAnalyzer theInstance = null; private DeltaExtractorJSON deltaExtractor; - private MethodExecution coordinator; - private ReferencePoint coordinatorPoint; - private List srcSidePoints = new ArrayList<>(); - private List dstSidePoints = new ArrayList<>(); - private ReferencePoint bottomPoint; - private Delta delta; - private static final String DELTA_MARKER_ID = "org.ntlab.traceDebugger.deltaMarker"; + private ExtractedStructure extractedStructure; public DeltaExtractionAnalyzer(Trace trace) { super(trace); deltaExtractor = new DeltaExtractorJSON((TraceJSON)trace); - JavaEditorOperator.deleteMarkers(DELTA_MARKER_ID); } + /** + * note: �I�����C����͗p + * @return + */ private static DeltaExtractionAnalyzer getInstance() { - if (getInstance == null) { - getInstance = new DeltaExtractionAnalyzer(TraceJSON.getInstance()); + if (theInstance == null) { + theInstance = new DeltaExtractionAnalyzer(TraceJSON.getInstance()); } - return getInstance; + return theInstance; } - public ReferencePoint getBottomPoint() { - return bottomPoint; - } - - public ReferencePoint getCoordinatorPoint() { - return coordinatorPoint; - } - - public List getSrcSidePoints() { - return srcSidePoints; - } - - public List getDstSidePoints() { - return dstSidePoints; + public ExtractedStructure geExtractedStructure() { + return extractedStructure; } - public void extractDelta(Variable variable) { + public DeltaMarkerManager extractDeltaForContainerToComponent(Variable variable) { String srcId = variable.getContainerId(); String srcClassName = variable.getContainerClassName(); - String dstId = variable.getId(); - String dstClassName = variable.getClassName(); - TracePoint before = variable.getTracePoint(); + String dstId = variable.getValueId(); + String dstClassName = variable.getValueClassName(); + TracePoint before = variable.getBeforeTracePoint(); + before = before.duplicate(); + before.stepNext(); Reference reference = new Reference(srcId, dstId, srcClassName, dstClassName); + reference.setCollection(srcClassName.startsWith("java.util.")); // true�ɂ���ƃR���N�V�����ȊO���o�ł��Ȃ��Ȃ� - reset(); - bottomPoint = createReferencePoint(reference, before, true); - coordinatorPoint = createCoordinatorReferencePoint(coordinator, bottomPoint.getMethodExecution()); - if (delta != null) { - for (Reference srcSideReference : delta.getSrcSide()) { - ReferencePoint rp = createReferencePoint(srcSideReference, before, false); - if (rp != null) srcSidePoints.add(rp); - } - for (Reference dstSideReference : delta.getDstSide()) { - ReferencePoint rp = createReferencePoint(dstSideReference, before, false); - if (rp != null) dstSidePoints.add(rp); - } - Collections.reverse(srcSidePoints); - Collections.reverse(dstSidePoints); - } - confirm(); - - String message; - int cnt = 1; - for (ReferencePoint rp : srcSidePoints) { - message = String.format("%s%03d: %s", "SrcSide", cnt, rp.getReferenceMessage()); - markAndOpenJavaFile(rp, message); - cnt++; - } - cnt = 1; - for (ReferencePoint rp : dstSidePoints) { - message = String.format("%s%03d: %s", "DstSide", cnt, rp.getReferenceMessage()); - markAndOpenJavaFile(rp, message); - cnt++; - } - message = String.format("%s: %s", "Coordinator", coordinatorPoint.getReferenceMessage()); - markAndOpenJavaFile(coordinatorPoint, message); - message = String.format("%s: %s", "Bottom", bottomPoint.getReferenceMessage()); - markAndOpenJavaFile(bottomPoint, message); - } - - private ReferencePoint createReferencePoint(Reference reference, TracePoint before, boolean isBottom) { - ExtractedStructure extractedStructure = deltaExtractor.extract(reference, before.duplicate()); - if (extractedStructure == null) return null; + // �f���^���o + DeltaRelatedAliasCollector aliasCollector = new DeltaRelatedAliasCollector(srcId, dstId); + extractedStructure = deltaExtractor.extract(reference, before.duplicate(), aliasCollector); MethodExecution creationCallTree = extractedStructure.getCreationCallTree(); - long beforeTime = before.getStatement().getTimeStamp(); - if (isBottom) { - coordinator = extractedStructure.getCoordinator(); - delta = extractedStructure.getDelta(); - } - return new ReferencePoint(reference, creationCallTree, beforeTime); + MethodExecution coordinator = extractedStructure.getCoordinator(); + TracePoint bottomPoint = findTracePoint(reference, creationCallTree, before.getStatement().getTimeStamp()); + return new DeltaMarkerManager(coordinator, bottomPoint, reference, aliasCollector); } - - private ReferencePoint createCoordinatorReferencePoint(MethodExecution coordinator, MethodExecution bottom) { - MethodExecution me = bottom; - MethodExecution childMe = null; - while (me != null) { - if (coordinator.equals(me)) break; - childMe = me; - me = me.getParent(); + + public DeltaMarkerManager extractDeltaForThisToAnother(String thisId, String thisClassName, String anotherId, String anotherClassName, TracePoint before) { + MethodExecution me = before.getMethodExecution(); + Map references = me.getObjectReferences(anotherClassName); + ObjectReference objectReference = null; + TracePoint tp = null; + for (Map.Entry entry : references.entrySet()) { + ObjectReference key = entry.getKey(); + if (key.getId().equals(anotherId)) { + objectReference = key; + tp = entry.getValue(); + break; + } } - Statement statement = null; - if (me != null && childMe != null) { - statement = me.getStatements().get(childMe.getCallerStatementExecution()); - } - return new ReferencePoint(null, me, statement); + + // �f���^���o + TracePoint bottomPoint = tp.duplicate(); + DeltaRelatedAliasCollector aliasCollector = new DeltaRelatedAliasCollector(thisId, anotherId); + extractedStructure = deltaExtractor.extract(tp, objectReference, aliasCollector); + MethodExecution coordinator = extractedStructure.getCoordinator(); + Reference reference = new Reference(thisId, anotherId, thisClassName, anotherClassName); + return new DeltaMarkerManager(coordinator, bottomPoint, reference, aliasCollector); } - - private void reset() { - coordinator = null; - srcSidePoints.clear(); - dstSidePoints.clear(); - bottomPoint = null; - delta = null; - JavaEditorOperator.deleteMarkers(DELTA_MARKER_ID); - } - - private void markAndOpenJavaFile(ReferencePoint rp, String message) { - if (rp == null) return; - MethodExecution methodExecution = rp.getMethodExecution(); - int lineNo = rp.getLineNo(); - JavaEditorOperator.markAndOpenJavaFile(methodExecution, lineNo, message, DELTA_MARKER_ID); - } - - private void confirm() { - System.out.println(); - System.out.println(); - System.out.println("Coordinator:"); - System.out.println(" " + coordinator); - System.out.println(); - System.out.println("SrcSide:"); - for (ReferencePoint point : srcSidePoints) { - System.out.println(" " + point); + + private TracePoint findTracePoint(Reference reference, MethodExecution methodExecution, long beforeTime) { + List statements = methodExecution.getStatements(); + for (int i = statements.size() - 1; i >= 0; i--) { + Statement statement = statements.get(i); + if (statement.getTimeStamp() > beforeTime) continue; + if (statement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)statement; + if (fu.getContainerObjId().equals(reference.getSrcObjectId()) + && fu.getValueObjId().equals(reference.getDstObjectId())) { + return new TracePoint(methodExecution, i); + } + } else if (statement instanceof MethodInvocation) { + MethodInvocation mi = (MethodInvocation)statement; + MethodExecution me = mi.getCalledMethodExecution(); + if (!(me.getThisObjId().equals(reference.getSrcObjectId()))) continue; + for (ObjectReference arg : me.getArguments()) { + if (arg.getId().equals(reference.getDstObjectId())) { + return new TracePoint(methodExecution, i); + } + } + } } - System.out.println(); - System.out.println("DstSide: "); - for (ReferencePoint point : dstSidePoints) { - System.out.println(" " + point); - } - System.out.println(); - System.out.println("Bottom:"); - System.out.println(" " + bottomPoint); - System.out.println(); + return null; } } \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzerLaunchConfiguration.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzerLaunchConfiguration.java new file mode 100644 index 0000000..a569f7c --- /dev/null +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzerLaunchConfiguration.java @@ -0,0 +1,28 @@ +package org.ntlab.traceDebugger.analyzerProvider; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.runtime.FileLocator; +import org.ntlab.traceAnalysisPlatform.IAdditionalLaunchConfiguration; + +public class DeltaExtractionAnalyzerLaunchConfiguration implements IAdditionalLaunchConfiguration { + public static final String ANALYZER_PATH = "org/ntlab/traceDebugger/analyzerProvider/DeltaExtractionAnalyzer.class"; + public static final String ANALYZER_PACKAGE = "org.ntlab.traceDebugger.analyzerProvider"; + public static final String ANALYZER_CLASS = "DeltaExtractionAnalyzer"; + + @Override + public String[] getAdditionalClasspaths() { + try { + List classPathList = new ArrayList<>(); + String tracerClassPath = FileLocator.resolve(this.getClass().getClassLoader().getResource(ANALYZER_PATH)).getPath(); + String classPath = tracerClassPath.substring(0, tracerClassPath.length() - ANALYZER_PATH.length()); + classPathList.add(classPath); + return classPathList.toArray(new String[classPathList.size()]); + } catch (IOException e) { + e.printStackTrace(); + } + throw new IllegalStateException(); + } +} diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.java index ca2a414..7743db9 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractor.java @@ -11,7 +11,7 @@ import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; - + /** * �f���^���o�A���S���Y��(�z��ւ̃A�N�Z�X�𐄑�����]���̃o�[�W����) * extract(...)���\�b�h�Q�Œ��o����B @@ -36,11 +36,19 @@ protected static final boolean DEBUG1 = true; protected static final boolean DEBUG2 = true; + protected final IAliasCollector defaultAliasCollector = new IAliasCollector() { + @Override + public void changeTrackingObject(String from, String to, boolean isSrcSide) { + } + @Override + public void addAlias(Alias alias) { + } + }; public DeltaExtractor(String traceFile) { trace = new Trace(traceFile); } - + public DeltaExtractor(Trace trace) { this.trace = trace; } @@ -72,7 +80,7 @@ // Reference[] lastRef) throws TraceFileException { // return trace.getLastCallTree(refs, colls, arrys, endLine, lastRef); // } - + /** * �f���^���o�A���S���Y���̌Ăяo�����T�������icalleeSearch�Ƒ��ݍċA�ɂȂ��Ă���j * @param trace�@��͑Ώۃg���[�X @@ -83,6 +91,19 @@ * @throws TraceFileException */ protected MethodExecution callerSearch(Trace trace, TracePoint tracePoint, ArrayList objList, MethodExecution childMethodExecution) { + return callerSearch(trace, tracePoint, objList, childMethodExecution, defaultAliasCollector); + } + + /** + * �f���^���o�A���S���Y���̌Ăяo�����T�������icalleeSearch�Ƒ��ݍċA�ɂȂ��Ă���j + * @param trace�@��͑Ώۃg���[�X + * @param methodExecution �T�����郁�\�b�h���s + * @param objList�@�ǐՒ��̃I�u�W�F�N�g + * @param child�@���O�ɒT�����Ă����Ăяo����̃��\�b�h���s + * @return ���‚������R�[�f�B�l�[�^ + * @throws TraceFileException + */ + protected MethodExecution callerSearch(Trace trace, TracePoint tracePoint, ArrayList objList, MethodExecution childMethodExecution, IAliasCollector aliasCollector) { MethodExecution methodExecution = tracePoint.getMethodExecution(); methodExecution.setAugmentation(new DeltaAugmentationInfo()); eStructure.createParent(methodExecution); @@ -134,7 +155,7 @@ removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� } } - + // �߂�l�ɒT���Ώۂ��܂܂�Ă����calleeSearch���ċA�Ăяo�� while (tracePoint.stepBackOver()) { Statement statement = tracePoint.getStatement(); @@ -228,7 +249,7 @@ ((DeltaAugmentationInfo)prevChildMethodExecution.getAugmentation()).setTraceObjectId(Integer.parseInt(retObj)); // �ǐՑΏ� TracePoint prevChildTracePoint = tracePoint.duplicate(); prevChildTracePoint.stepBackNoReturn(); - calleeSearch(trace, prevChildTracePoint, objList, prevChildMethodExecution.isStatic(), retIndex); // �Ăяo�����T�� + calleeSearch(trace, prevChildTracePoint, objList, prevChildMethodExecution.isStatic(), retIndex, aliasCollector); // �Ăяo�����T�� if (objList.get(retIndex) != null && objList.get(retIndex).equals(prevChildMethodExecution.getThisObjId()) && thisObjectId.equals(prevChildMethodExecution.getThisObjId())) { // �Ăяo����Ńt�B�[���h�Ɉˑ����Ă����ꍇ�̏��� @@ -272,7 +293,7 @@ if (methodExecution.isCollectionType()) { objList.add(thisObjectId); } - + // �����̎擾 ArrayList argments = methodExecution.getArguments(); @@ -418,7 +439,7 @@ // } if (tracePoint.isValid()) { finalCount = 0; - return callerSearch(trace, tracePoint, objList, methodExecution); // �Ăяo����������ɒT�� + return callerSearch(trace, tracePoint, objList, methodExecution, aliasCollector); // �Ăяo����������ɒT�� } } @@ -434,7 +455,7 @@ if (finalCount <= LOST_DECISION_EXTENSION) { // final�ϐ����Q�Ƃ��Ă���ꍇ�R���������ł��Ȃ��”\��������̂ŁA�ǐՂ������I�������P�\���Ԃ�݂��� if (tracePoint.isValid()) { - MethodExecution c = callerSearch(trace, tracePoint, objList, methodExecution); // �Ăяo����������ɒT�� + MethodExecution c = callerSearch(trace, tracePoint, objList, methodExecution, aliasCollector); // �Ăяo����������ɒT�� if (((DeltaAugmentationInfo)c.getAugmentation()).isCoodinator()) { methodExecution = c; // �ǐՂ𑱂������ʃR�[�f�B�l�[�^�����‚����� } @@ -479,7 +500,7 @@ finalCount = 0; return methodExecution; } - + /** * �f���^���o�A���S���Y���̌Ăяo����T������(�ċA�Ăяo���ɂȂ��Ă���) * @param trace ��͑Ώۃg���[�X @@ -489,7 +510,7 @@ * @param index�@objList���̂ǂ̃I�u�W�F�N�g��ǐՂ��Ă��̃��\�b�h���s�ɓ����Ă����̂� * @throws TraceFileException */ - protected void calleeSearch(Trace trace, TracePoint tracePoint, ArrayList objList, Boolean isStatic, int index) { + protected void calleeSearch(Trace trace, TracePoint tracePoint, ArrayList objList, Boolean isStatic, int index, IAliasCollector aliasCollector) { MethodExecution methodExecution = tracePoint.getMethodExecution(); Boolean isResolved = false; String objectId = objList.get(index); // calleeSearch() �ł͒ǐՑΏۂ̃I�u�W�F�N�g�͈�‚����A��objList��index�Ԗڂ̗v�f�ȊO�ύX���Ă͂����Ȃ� @@ -589,7 +610,7 @@ ((DeltaAugmentationInfo)childMethodExecution.getAugmentation()).setTraceObjectId(Integer.parseInt(objectId)); TracePoint childTracePoint = tracePoint.duplicate(); childTracePoint.stepBackNoReturn(); - calleeSearch(trace, childTracePoint, objList, childMethodExecution.isStatic(), index); // �Ăяo���������ɒT�� + calleeSearch(trace, childTracePoint, objList, childMethodExecution.isStatic(), index, aliasCollector); // �Ăяo���������ɒT�� if (childMethodExecution.isConstructor()) { // �R���X�g���N�^�Ăяo���������ꍇ if (objectId.equals(srcObject.getId())) { @@ -764,12 +785,23 @@ } /** - * �݌v�ύX��̃A���S���Y���̋N�����\�b�h(������) + * �Q�ƌ��I�u�W�F�N�g�ƎQ�Ɛ�I�u�W�F�N�g���֘A�t�����f���^���A�Q�Ƃ��w�肵�Ē��o���� * @param targetRef �ΏۂƂȂ�Q�� * @param before �T���J�n�g���[�X�|�C���g(������ȑO��T��) * @return ���o���� */ public ExtractedStructure extract(Reference targetRef, TracePoint before) { + return extract(targetRef, before, defaultAliasCollector); + } + + /** + * �Q�ƌ��I�u�W�F�N�g�ƎQ�Ɛ�I�u�W�F�N�g���֘A�t�����f���^���A�Q�Ƃ��w�肵�Ē��o���� + * @param targetRef �ΏۂƂȂ�Q�� + * @param before �T���J�n�g���[�X�|�C���g(������ȑO��T��) + * @param aliasCollector �f���^���o���ɒǐՂ����I�u�W�F�N�g�̑S�G�C���A�X�����W���郊�X�i + * @return ���o���� + */ + public ExtractedStructure extract(Reference targetRef, TracePoint before, IAliasCollector aliasCollector) { TracePoint creationTracePoint; if (targetRef.isArray()) { // srcId �̔z��� dstId ���������Ă���”\�������郁�\�b�h���s���擾�i�z���p�̏����j @@ -788,11 +820,11 @@ if (creationTracePoint == null) { return null; } - return extractSub(creationTracePoint, targetRef); + return extractSub(creationTracePoint, targetRef, aliasCollector); } /** - * �݌v�ύX��̃A���S���Y���̋N�����\�b�h(������) + * �Q�ƌ��I�u�W�F�N�g�ƎQ�Ɛ�I�u�W�F�N�g���֘A�t�����f���^���A�I�u�W�F�N�g�ԎQ�Ƃ��������ꂽ�g���[�X�|�C���g���w�肵�Ē��o���� * @param creationTracePoint �I�u�W�F�N�g�ԎQ�Ɛ����g���[�X�|�C���g(�t�B�[���h�ւ̑��) * @return ���o���� */ @@ -801,13 +833,30 @@ Statement statement = creationTracePoint.getStatement(); if (statement instanceof FieldUpdate) { Reference targetRef = ((FieldUpdate)statement).getReference(); - return extractSub(creationTracePoint, targetRef); + return extractSub(creationTracePoint, targetRef, defaultAliasCollector); } else { return null; } } - - private ExtractedStructure extractSub(TracePoint creationTracePoint, Reference targetRef) { + + /** + * �Q�ƌ��I�u�W�F�N�g�ƎQ�Ɛ�I�u�W�F�N�g���֘A�t�����f���^���A�I�u�W�F�N�g�ԎQ�Ƃ��������ꂽ�g���[�X�|�C���g���w�肵�Ē��o���� + * @param creationTracePoint �I�u�W�F�N�g�ԎQ�Ɛ����g���[�X�|�C���g(�t�B�[���h�ւ̑��) + * @param aliasCollector �f���^���o���ɒǐՂ����I�u�W�F�N�g�̑S�G�C���A�X�����W���郊�X�i + * @return ���o���� + */ + public ExtractedStructure extract(TracePoint creationTracePoint, IAliasCollector aliasCollector) { + creationTracePoint = creationTracePoint.duplicate(); + Statement statement = creationTracePoint.getStatement(); + if (statement instanceof FieldUpdate) { + Reference targetRef = ((FieldUpdate)statement).getReference(); + return extractSub(creationTracePoint, targetRef, aliasCollector); + } else { + return null; + } + } + + private ExtractedStructure extractSub(TracePoint creationTracePoint, Reference targetRef, IAliasCollector aliasCollector) { eStructure = new ExtractedStructure(); ArrayList objList = new ArrayList(); srcObject = targetRef.getSrcObject(); @@ -825,28 +874,68 @@ } else { objList.add(null); } - return extractSub2(creationTracePoint, objList); + return extractSub2(creationTracePoint, objList, aliasCollector); } - - public ExtractedStructure extract(TracePoint tracePoint, ObjectReference argObj) { - MethodExecution methodExecution = tracePoint.getMethodExecution(); + + /** + * �Ăяo�����I�u�W�F�N�g�ƌĂяo����I�u�W�F�N�g���֘A�t�����f���^���A�Ăяo���惁�\�b�h���s���w�肵�Ē��o���� + * @param calledMethodExecution �Ăяo���惁�\�b�h���s + * @return�@���o���� + */ + public ExtractedStructure extract(MethodExecution calledMethodExecution) { + return extract(calledMethodExecution, defaultAliasCollector); + } + + /** + * �Ăяo�����I�u�W�F�N�g�ƌĂяo����I�u�W�F�N�g���֘A�t�����f���^���A�Ăяo���惁�\�b�h���s���w�肵�Ē��o���� + * @param calledMethodExecution �Ăяo���惁�\�b�h���s + * @param aliasCollector �f���^���o���ɒǐՂ����I�u�W�F�N�g�̑S�G�C���A�X�����W���郊�X�i + * @return�@���o���� + */ + public ExtractedStructure extract(MethodExecution calledMethodExecution, IAliasCollector aliasCollector) { + ObjectReference callee = new ObjectReference(calledMethodExecution.getThisObjId(), calledMethodExecution.getThisClassName()); + return extract(calledMethodExecution.getCallerTracePoint(), callee, aliasCollector); + } + + /** + * �����ithis�I�u�W�F�N�g�j�Ǝ��������\�b�h���ŎQ�Ƃ����I�u�W�F�N�g���֘A�t�����f���^�𒊏o���� + * @param thisTracePoint �Q�Ƃ������������_ + * @param anotherObj �Q�Ƃ����I�u�W�F�N�g + * @return ���o���� + */ + public ExtractedStructure extract(TracePoint thisTracePoint, ObjectReference anotherObj) { + return extract(thisTracePoint, anotherObj, defaultAliasCollector); + } + + /** + * �����ithis�I�u�W�F�N�g�j�ƃ��\�b�h���ŎQ�Ƃ��ꂽ�I�u�W�F�N�g���֘A�t�����f���^�𒊏o���� + * @param thisTracePoint �Q�Ƃ������������_ + * @param anotherObj �Q�Ƃ����I�u�W�F�N�g + * @param aliasCollector �f���^���o���ɒǐՂ����I�u�W�F�N�g�̑S�G�C���A�X�����W���郊�X�i + * @return ���o���� + */ + public ExtractedStructure extract(TracePoint thisTracePoint, ObjectReference anotherObj, IAliasCollector aliasCollector) { + MethodExecution methodExecution = thisTracePoint.getMethodExecution(); + if (!thisTracePoint.isMethodEntry()) { + thisTracePoint.stepNext(); + } eStructure = new ExtractedStructure(); ArrayList objList = new ArrayList(); String thisObjectId = methodExecution.getThisObjId(); objList.add(thisObjectId); - objList.add(argObj.getId()); + objList.add(anotherObj.getId()); srcObject = new ObjectReference(thisObjectId, methodExecution.getThisClassName(), Trace.getDeclaringType(methodExecution.getSignature(), methodExecution.isConstructor()), Trace.getDeclaringType(methodExecution.getCallerSideSignature(), methodExecution.isConstructor())); - dstObject = argObj; + dstObject = anotherObj; if (DEBUG1) { - System.out.println("extract delta of:" + methodExecution.getSignature() + " -> " + argObj.getActualType() + "(" + argObj.getId() + ")"); + System.out.println("extract delta of:" + methodExecution.getSignature() + " -> " + anotherObj.getActualType() + "(" + anotherObj.getId() + ")"); } - return extractSub2(tracePoint, objList); + return extractSub2(thisTracePoint, objList, aliasCollector); } - private ExtractedStructure extractSub2(TracePoint creationTracePoint, ArrayList objList) { - eStructure.setCreationMethodExecution(creationTracePoint.getMethodExecution()); - MethodExecution coordinator = callerSearch(trace, creationTracePoint, objList, null); + private ExtractedStructure extractSub2(TracePoint tracePoint, ArrayList objList, IAliasCollector aliasCollector) { + eStructure.setCreationMethodExecution(tracePoint.getMethodExecution()); + MethodExecution coordinator = callerSearch(trace, tracePoint, objList, null, aliasCollector); eStructure.setCoordinator(coordinator); if (DEBUG2) { if (((DeltaAugmentationInfo)coordinator.getAugmentation()).isCoodinator()) { @@ -880,38 +969,59 @@ } /** - * �Q�ƌ��ƎQ�Ɛ�̃I�u�W�F�N�g���w�肵�ăf���^�𒊏o����(�I�����C����͗p) - * @param srcObj �Q�ƌ��I�u�W�F�N�g - * @param dstObj �Q�Ɛ�I�u�W�F�N�g + * ���ۂ̎Q�ƌ��ƎQ�Ɛ�̃I�u�W�F�N�g���w�肵�ăf���^�𒊏o����(�I�����C����͗p) + * @param srcObj ��������ɂ���Q�ƌ��I�u�W�F�N�g + * @param dstObj ��������ɂ���Q�Ɛ�I�u�W�F�N�g * @param before �T���J�n�g���[�X�|�C���g(������ȑO��T��) * @return�@���o���� */ public ExtractedStructure extract(Object srcObj, Object dstObj, TracePoint before) { - Reference targetRef = new Reference(Integer.toString(System.identityHashCode(srcObj)), Integer.toString(System.identityHashCode(dstObj)), null, null); - return extract(targetRef, before); + return extract(srcObj, dstObj, before, defaultAliasCollector); } - /** - * ���\�b�h���s���̃g���[�X�|�C���g�ƎQ�Ɛ�I�u�W�F�N�g���w�肵�ăf���^�𒊏o����(�I�����C����͗p) + * ���ۂ̎Q�ƌ��ƎQ�Ɛ�̃I�u�W�F�N�g���w�肵�ăf���^�𒊏o����(�I�����C����͗p) + * @param srcObj ��������ɂ���Q�ƌ��I�u�W�F�N�g + * @param dstObj ��������ɂ���Q�Ɛ�I�u�W�F�N�g + * @param before �T���J�n�g���[�X�|�C���g(������ȑO��T��) + * @param aliasCollector �f���^���o���ɒǐՂ����I�u�W�F�N�g�̑S�G�C���A�X�����W���郊�X�i + * @return�@���o���� + */ + public ExtractedStructure extract(Object srcObj, Object dstObj, TracePoint before, IAliasCollector aliasCollector) { + Reference targetRef = new Reference(Integer.toString(System.identityHashCode(srcObj)), Integer.toString(System.identityHashCode(dstObj)), null, null); + return extract(targetRef, before, aliasCollector); + } + + /** + * ���\�b�h���s���̃g���[�X�|�C���g�Ǝ��ۂ̎Q�Ɛ�I�u�W�F�N�g���w�肵�ăf���^�𒊏o����(�I�����C����͗p) * @param tracePoint ���\�b�h���s���̃g���[�X�|�C���g - * @param arg �Q�Ɛ�I�u�W�F�N�g(���[�J���ϐ�������ɂ��Q�Ɛ�) + * @param arg ��������ɂ���Q�Ɛ�I�u�W�F�N�g(���[�J���ϐ�������ɂ��Q�Ɛ�) * @return ���o���� */ public ExtractedStructure extract(TracePoint tracePoint, Object arg) { - ObjectReference argObj = new ObjectReference(Integer.toString(System.identityHashCode(arg))); - return extract(tracePoint, argObj); + return extract(tracePoint, arg, defaultAliasCollector); } /** - * �w�肵���X���b�h��Ō��ݎ��s���̃��\�b�h���s���擾����(�I�����C����͗p) - * @param thread �ΏۃX���b�h + * ���\�b�h���s���̃g���[�X�|�C���g�Ǝ��ۂ̎Q�Ɛ�I�u�W�F�N�g���w�肵�ăf���^�𒊏o����(�I�����C����͗p) + * @param tracePoint ���\�b�h���s���̃g���[�X�|�C���g + * @param arg ��������ɂ���Q�Ɛ�I�u�W�F�N�g(���[�J���ϐ�������ɂ��Q�Ɛ�) + * @return ���o���� + */ + public ExtractedStructure extract(TracePoint tracePoint, Object arg, IAliasCollector aliasCollector) { + ObjectReference argObj = new ObjectReference(Integer.toString(System.identityHashCode(arg))); + return extract(tracePoint, argObj, aliasCollector); + } + + /** + * �w�肵�����ۂ̃X���b�h��Ō��ݎ��s���̃��\�b�h���s���擾����(�I�����C����͗p) + * @param thread ���ݎ��s���̑ΏۃX���b�h * @return thread ��Ō��ݎ��s���̃��\�b�h���s */ public MethodExecution getCurrentMethodExecution(Thread thread) { return trace.getCurrentMethodExecution(thread); } - + /** * methodSignature �ɑO����v���郁�\�b�h�������ƒ��\�b�h�̍Ō�̎��s * @param methodSignature ���\�b�h��(�O����v�Ō�������) @@ -920,7 +1030,7 @@ public MethodExecution getLastMethodExecution(String methodSignature) { return trace.getLastMethodExecution(methodSignature); } - + /** * methodSignature �ɑO����v���郁�\�b�h�������ƒ��\�b�h�� before �ȑO�̍Ō�̎��s * @param methodSignature ���\�b�h��(�O����v�Ō�������) @@ -930,7 +1040,7 @@ public MethodExecution getLastMethodExecution(String methodSignature, TracePoint before) { return trace.getLastMethodExecution(methodSignature, before); } - + public ArrayList getMethodExecutions(String methodSignature) { return trace.getMethodExecutions(methodSignature); } @@ -1038,4 +1148,4 @@ //} // return eStructure; // } -} +} \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.java index 29b2b9f..8acae26 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaExtractorJSON.java @@ -1,10 +1,16 @@ package org.ntlab.traceDebugger.analyzerProvider; - + +import java.util.AbstractMap; import java.util.ArrayList; - +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map.Entry; + 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.ObjectReference; @@ -13,8 +19,7 @@ import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; - - + /** * �f���^���o�A���S���Y��(�z��ւ̃A�N�Z�X�����m�ł���Javassist��JSON�g���[�X�ɑΉ����A�A���S���Y����P����) * @@ -25,11 +30,11 @@ public DeltaExtractorJSON(String traceFile) { super(new TraceJSON(traceFile)); } - + public DeltaExtractorJSON(TraceJSON trace) { super(trace); } - + /** * �f���^���o�A���S���Y���̌Ăяo�����T�������icalleeSearch�Ƒ��ݍċA�ɂȂ��Ă���j * @param trace�@��͑Ώۃg���[�X @@ -39,7 +44,7 @@ * @return ���‚������R�[�f�B�l�[�^ * @throws TraceFileException */ - protected MethodExecution callerSearch(Trace trace, TracePoint tracePoint, ArrayList objList, MethodExecution childMethodExecution) { + protected MethodExecution callerSearch(Trace trace, TracePoint tracePoint, ArrayList objList, MethodExecution childMethodExecution, IAliasCollector aliasCollector) { MethodExecution methodExecution = tracePoint.getMethodExecution(); methodExecution.setAugmentation(new DeltaAugmentationInfo()); eStructure.createParent(methodExecution); @@ -52,6 +57,8 @@ ObjectReference thisObj = new ObjectReference(thisObjectId, methodExecution.getThisClassName(), Trace.getDeclaringType(methodExecution.getSignature(), methodExecution.isConstructor()), Trace.getDeclaringType(methodExecution.getCallerSideSignature(), methodExecution.isConstructor())); + HashMap aliasList = new HashMap<>(); + if (childMethodExecution == null) { // �T���J�n���͈�U�폜���A�Ăяo�����̒T���𑱂���ۂɕ��������� removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� @@ -65,6 +72,16 @@ removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� isTrackingThis = true; // �Ăяo�����T���O�ɕ��� } + + aliasCollector.addAlias(new Alias(Alias.AliasType.RECEIVER, 0, childMethodExecution.getThisObjId(), tracePoint.duplicate())); + } + + if (childMethodExecution != null) { + for (String objId : objList) { + if (!objId.equals(childMethodExecution.getThisObjId())) { + aliasCollector.addAlias(new Alias(Alias.AliasType.ACTUAL_ARGUMENT, -1, objId, tracePoint.duplicate())); // argIndex�͕s�� + } + } } if (childMethodExecution != null && childMethodExecution.isConstructor()) { @@ -89,7 +106,7 @@ removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� } } - + // �߂�l�ɒT���Ώۂ��܂܂�Ă����calleeSearch���ċA�Ăяo�� while (tracePoint.stepBackOver()) { Statement statement = tracePoint.getStatement(); @@ -100,23 +117,31 @@ int index = objList.indexOf(refObjectId); if (index != -1) { String ownerObjectId = fs.getContainerObjId(); + if (ownerObjectId.equals(thisObjectId)) { // �t�B�[���h�Q�Ƃ̏ꍇ removeList.add(refObjectId); existsInFields++; // set�������get�����o���Ă���”\�������� - removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� + removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� + aliasList.put(refObjectId, new Alias(Alias.AliasType.FIELD, 0, refObjectId, tracePoint.duplicate())); } else { // ���ڎQ�Ƃ̏ꍇ + boolean isSrcSideChanged = false; if (refObjectId.equals(srcObject.getId())) { eStructure.addSrcSide(new Reference(ownerObjectId, refObjectId, fs.getContainerClassName(), srcObject.getActualType())); srcObject = new ObjectReference(ownerObjectId, fs.getContainerClassName()); + isSrcSideChanged = true; } else if(refObjectId.equals(dstObject.getId())) { eStructure.addDstSide(new Reference(ownerObjectId, refObjectId, fs.getContainerClassName(), dstObject.getActualType())); dstObject = new ObjectReference(ownerObjectId, fs.getContainerClassName()); + isSrcSideChanged = false; } objList.set(index, ownerObjectId); + aliasCollector.addAlias(new Alias(Alias.AliasType.FIELD, 0, refObjectId, tracePoint.duplicate())); + aliasCollector.changeTrackingObject(refObjectId, ownerObjectId, isSrcSideChanged); //�ǐՑΏۃI�u�W�F�N�g�̐؂�ւ� + aliasCollector.addAlias(new Alias(Alias.AliasType.CONTAINER, 0, ownerObjectId, tracePoint.duplicate())); } } } else if (statement instanceof ArrayAccess) { @@ -125,17 +150,23 @@ int index = objList.indexOf(elementObjectId); if (index != -1) { // �z��A�N�Z�X�̏ꍇ + boolean isSrcSideChanged = false; String arrayObjectId = aa.getArrayObjectId(); if (elementObjectId.equals(srcObject.getId())) { eStructure.addSrcSide(new Reference(arrayObjectId, elementObjectId, aa.getArrayClassName(), srcObject.getActualType())); srcObject = new ObjectReference(arrayObjectId, aa.getArrayClassName()); + isSrcSideChanged = true; } else if(elementObjectId.equals(dstObject.getId())) { eStructure.addDstSide(new Reference(arrayObjectId, elementObjectId, aa.getArrayClassName(), dstObject.getActualType())); dstObject = new ObjectReference(arrayObjectId, aa.getArrayClassName()); + isSrcSideChanged = false; } objList.set(index, arrayObjectId); + aliasCollector.addAlias(new Alias(Alias.AliasType.ARRAY_ELEMENT, aa.getIndex(), elementObjectId, tracePoint.duplicate())); + aliasCollector.changeTrackingObject(elementObjectId, arrayObjectId, isSrcSideChanged); //�ǐՑΏۃI�u�W�F�N�g�̐؂�ւ� + aliasCollector.addAlias(new Alias(Alias.AliasType.ARRAY, 0, arrayObjectId, tracePoint.duplicate())); } } else if (statement instanceof ArrayCreate) { ArrayCreate ac = (ArrayCreate)statement; @@ -147,6 +178,7 @@ removeList.add(arrayObjectId); existsInFields++; removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� + aliasList.put(arrayObjectId, new Alias(Alias.AliasType.ARRAY_CREATE, 0, arrayObjectId, tracePoint.duplicate())); } } else if (statement instanceof MethodInvocation) { MethodExecution prevChildMethodExecution = ((MethodInvocation)statement).getCalledMethodExecution(); @@ -159,6 +191,7 @@ if (retIndex != -1) { // �߂�l���R�������� prevChildMethodExecution.setAugmentation(new DeltaAugmentationInfo()); + if (prevChildMethodExecution.isConstructor()) { // �ǐՑΏۂ�constractor���Ă�ł�����(�I�u�W�F�N�g�̐�����������)field�Ɠ��l�ɏ��� String newObjId = ret.getId(); @@ -168,9 +201,11 @@ removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� ((DeltaAugmentationInfo)prevChildMethodExecution.getAugmentation()).setTraceObjectId(Integer.parseInt(newObjId)); // �ǐՑΏ� ((DeltaAugmentationInfo)prevChildMethodExecution.getAugmentation()).setSetterSide(false); // getter�Ăяo���Ɠ��l + aliasList.put(newObjId, new Alias(Alias.AliasType.CONSTRACTOR_INVOCATION, 0, newObjId, tracePoint.duplicate())); continue; } String retObj = objList.get(retIndex); + aliasCollector.addAlias(new Alias(Alias.AliasType.METHOD_INVOCATION, 0, retObj, tracePoint.duplicate())); if (removeList.contains(retObj)) { // ��xget�Ō��o���ăt�B�[���h�Ɉˑ����Ă���Ɣ��f�������{���̗R�����߂�l���������Ƃ����������̂ŁA�t�B�[���h�ւ̈ˑ����L�����Z������ removeList.remove(retObj); @@ -182,12 +217,14 @@ ((DeltaAugmentationInfo)prevChildMethodExecution.getAugmentation()).setTraceObjectId(Integer.parseInt(retObj)); // �ǐՑΏ� TracePoint prevChildTracePoint = tracePoint.duplicate(); prevChildTracePoint.stepBackNoReturn(); - calleeSearch(trace, prevChildTracePoint, objList, prevChildMethodExecution.isStatic(), retIndex); // �Ăяo�����T�� - if (objList.get(retIndex) != null && objList.get(retIndex).equals(prevChildMethodExecution.getThisObjId()) - && thisObjectId.equals(prevChildMethodExecution.getThisObjId())) { - // �Ăяo����Ńt�B�[���h�Ɉˑ����Ă����ꍇ�̏��� - removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� - isTrackingThis = true; // �Ăяo�����T���O�ɕ��� + calleeSearch(trace, prevChildTracePoint, objList, prevChildMethodExecution.isStatic(), retIndex, aliasCollector); // �Ăяo�����T�� + if (objList.get(retIndex) != null && objList.get(retIndex).equals(prevChildMethodExecution.getThisObjId())) { + if ( thisObjectId.equals(prevChildMethodExecution.getThisObjId())) { + // �Ăяo����Ńt�B�[���h�Ɉˑ����Ă����ꍇ�̏��� + removeList.add(thisObjectId); // ��ň�U�AthisObject ����菜�� + isTrackingThis = true; // �Ăяo�����T���O�ɕ��� + } + aliasCollector.addAlias(new Alias(Alias.AliasType.RECEIVER, 0, objList.get(retIndex), tracePoint.duplicate())); } if (isLost) { checkList.add(objList.get(retIndex)); @@ -204,16 +241,16 @@ if (methodExecution.isCollectionType()) { objList.add(thisObjectId); } - + // �����̎擾 - ArrayList argments = methodExecution.getArguments(); + ArrayList arguments = methodExecution.getArguments(); // �����ƃt�B�[���h�ɓ���ID�̃I�u�W�F�N�g������ꍇ��z�� Reference r; for (int i = 0; i < removeList.size(); i++) { String removeId = removeList.get(i); - if (argments.contains(new ObjectReference(removeId))) { - removeList.remove(removeId); // �t�B�[���h�ƈ����̗����ɒǐՑΏۂ����݂����ꍇ�A������D�� + if (arguments.contains(new ObjectReference(removeId))) { + removeList.remove(removeId); // �t�B�[���h�ƈ����̗����ɒǐՑΏۂ����݂����ꍇ�A������D��(���A�P�[�X) } else if(objList.contains(removeId)) { // �t�B�[���h�ɂ����Ȃ������ꍇ(�������A�I�u�W�F�N�g�̐������t�B�[���h�Ɠ��l�Ɉ���) objList.remove(removeId); // �ǐՑΏۂ���O�� @@ -231,7 +268,10 @@ eStructure.addDstSide(r); dstObject = thisObj; isSrcSide = false; - } + } + aliasCollector.addAlias(aliasList.get(removeId)); + aliasCollector.changeTrackingObject(removeId, thisObjectId, isSrcSide); + aliasCollector.addAlias(new Alias(Alias.AliasType.THIS, 0, thisObjectId, aliasList.get(removeId).getOccurrencePoint())); } } } @@ -243,10 +283,11 @@ String objectId = objList.get(i); if (objectId != null) { ObjectReference trackingObj = new ObjectReference(objectId); - if (argments.contains(trackingObj)) { + if (arguments.contains(trackingObj)) { // �������R�������� existsInAnArgument = true; ((DeltaAugmentationInfo)methodExecution.getAugmentation()).setTraceObjectId(Integer.parseInt(objectId)); + aliasCollector.addAlias(new Alias(Alias.AliasType.FORMAL_PARAMETER, arguments.indexOf(trackingObj), trackingObj.getId(), methodExecution.getEntryPoint())); } else { // �R�����ǂ��ɂ����‚���Ȃ����� boolean isSrcSide2 = true; @@ -266,14 +307,14 @@ if (existsInFields > 0 || isTrackingThis) { // this�I�u�W�F�N�g��ǐՒ��̏ꍇ if (!Trace.isNull(thisObjectId)) { - objList.add(thisObjectId); // ����ɒT������ꍇ�A��U��菜���� thisObject �𕜊� + objList.add(thisObjectId); // ����ɒT������ꍇ�A��U��菜���� thisObject �𕜊� } else { objList.add(null); // ������static�Ăяo���������ꍇ�A����ȏ�ǐՂ��Ȃ� } } if (tracePoint.isValid()) { finalCount = 0; - return callerSearch(trace, tracePoint, objList, methodExecution); // �Ăяo����������ɒT�� + return callerSearch(trace, tracePoint, objList, methodExecution, aliasCollector); // �Ăяo����������ɒT�� } } @@ -289,7 +330,7 @@ if (finalCount <= LOST_DECISION_EXTENSION) { // final�ϐ����Q�Ƃ��Ă���ꍇ�R���������ł��Ȃ��”\��������̂ŁA�ǐՂ������I�������P�\���Ԃ�݂��� if (tracePoint.isValid()) { - MethodExecution c = callerSearch(trace, tracePoint, objList, methodExecution); // �Ăяo����������ɒT�� + MethodExecution c = callerSearch(trace, tracePoint, objList, methodExecution, aliasCollector); // �Ăяo����������ɒT�� if (((DeltaAugmentationInfo)c.getAugmentation()).isCoodinator()) { methodExecution = c; // �ǐՂ𑱂������ʃR�[�f�B�l�[�^�����‚����� } @@ -334,7 +375,7 @@ finalCount = 0; return methodExecution; } - + /** * �f���^���o�A���S���Y���̌Ăяo����T������(�ċA�Ăяo���ɂȂ��Ă���) * @param trace ��͑Ώۃg���[�X @@ -344,7 +385,7 @@ * @param index�@objList���̂ǂ̃I�u�W�F�N�g��ǐՂ��Ă��̃��\�b�h���s�ɓ����Ă����̂� * @throws TraceFileException */ - protected void calleeSearch(Trace trace, TracePoint tracePoint, ArrayList objList, Boolean isStatic, int index) { + protected void calleeSearch(Trace trace, TracePoint tracePoint, ArrayList objList, Boolean isStatic, int index, IAliasCollector aliasCollector) { MethodExecution methodExecution = tracePoint.getMethodExecution(); Boolean isResolved = false; String objectId = objList.get(index); // calleeSearch() �ł͒ǐՑΏۂ̃I�u�W�F�N�g�͈�‚����A��objList��index�Ԗڂ̗v�f�ȊO�ύX���Ă͂����Ȃ� @@ -354,8 +395,10 @@ Trace.getDeclaringType(methodExecution.getCallerSideSignature(), methodExecution.isConstructor())); ((DeltaAugmentationInfo)methodExecution.getAugmentation()).setSetterSide(false); // ��{�I��getter�Ăяo���̂͂������A���� - ArrayList argments = methodExecution.getArguments(); + ArrayList arguments = methodExecution.getArguments(); ObjectReference trackingObj = null; + + aliasCollector.addAlias(new Alias(Alias.AliasType.RETURN_VALUE, 0, objectId, tracePoint.duplicate())); //static���o�R�����null�������Ă��鎞������ if (objectId != null) { String returnType = Trace.getReturnType(methodExecution.getSignature()); @@ -377,35 +420,47 @@ // ���ڎQ�Ƃ���уt�B�[���h�Q�Ƃ̒T�� if (statement instanceof FieldAccess) { FieldAccess fs = (FieldAccess)statement; - if (objectId != null && objectId.equals(fs.getValueObjId())) { + if (objectId != null && objectId.equals(fs.getValueObjId())) { String ownerObjectId = fs.getContainerObjId(); if (ownerObjectId.equals(thisObjectId)) { // �t�B�[���h�Q�Ƃ̏ꍇ + boolean isSrcSideChanged = false; if (objectId.equals(srcObject.getId())) { eStructure.addSrcSide(new Reference(thisObj, srcObject)); srcObject = thisObj; trackingObj = srcObject; + isSrcSideChanged = true; } else if(objectId.equals(dstObject.getId())) { eStructure.addDstSide(new Reference(thisObj, dstObject)); dstObject = thisObj; trackingObj = dstObject; + isSrcSideChanged = false; } + aliasCollector.addAlias(new Alias(Alias.AliasType.FIELD, 0, objectId, tracePoint.duplicate())); + aliasCollector.changeTrackingObject(objectId, ownerObjectId, isSrcSideChanged); + aliasCollector.addAlias(new Alias(Alias.AliasType.THIS, 0, ownerObjectId, tracePoint.duplicate())); if (Trace.isNull(thisObjectId)) objectId = null; // static�ϐ��̏ꍇ else objectId = thisObjectId; objList.set(index, objectId); } else { // ���ڎQ�Ƃ̏ꍇ + boolean isSrcSideChanged = false; if (objectId.equals(srcObject.getId())) { eStructure.addSrcSide(new Reference(ownerObjectId, objectId, fs.getContainerClassName(), srcObject.getActualType())); srcObject = new ObjectReference(ownerObjectId, fs.getContainerClassName()); trackingObj = srcObject; + isSrcSideChanged = true; } else if(objectId.equals(dstObject.getId())) { eStructure.addDstSide(new Reference(ownerObjectId, objectId, fs.getContainerClassName(), dstObject.getActualType())); dstObject = new ObjectReference(ownerObjectId, fs.getContainerClassName()); trackingObj = dstObject; + isSrcSideChanged = false; } + aliasCollector.addAlias(new Alias(Alias.AliasType.FIELD, 0, objectId, tracePoint.duplicate())); + aliasCollector.changeTrackingObject(objectId, ownerObjectId, isSrcSideChanged); + aliasCollector.addAlias(new Alias(Alias.AliasType.CONTAINER, 0, ownerObjectId, tracePoint.duplicate())); if (Trace.isNull(ownerObjectId)) objectId = null; // static�ϐ��̏ꍇ else objectId = ownerObjectId; objList.set(index, objectId); @@ -416,18 +471,24 @@ ArrayAccess aa = (ArrayAccess)statement; if (objectId != null && objectId.equals(aa.getValueObjectId())) { // �z��A�N�Z�X�̏ꍇ + boolean isSrcSideChanged = false; String arrayObjectId = aa.getArrayObjectId(); if (objectId.equals(srcObject.getId())) { eStructure.addSrcSide(new Reference(arrayObjectId, objectId, aa.getArrayClassName(), srcObject.getActualType())); srcObject = new ObjectReference(arrayObjectId, aa.getArrayClassName()); trackingObj = srcObject; + isSrcSideChanged = true; } else if(objectId.equals(dstObject.getId())) { eStructure.addDstSide(new Reference(arrayObjectId, objectId, aa.getArrayClassName(), dstObject.getActualType())); dstObject = new ObjectReference(arrayObjectId, aa.getArrayClassName()); trackingObj = dstObject; + isSrcSideChanged = false; } + aliasCollector.addAlias(new Alias(Alias.AliasType.ARRAY_ELEMENT, aa.getIndex(), objectId, tracePoint.duplicate())); + aliasCollector.changeTrackingObject(objectId, arrayObjectId, isSrcSideChanged); + aliasCollector.addAlias(new Alias(Alias.AliasType.ARRAY, 0, arrayObjectId, tracePoint.duplicate())); objectId = arrayObjectId; objList.set(index, objectId); isResolved = true; @@ -436,15 +497,21 @@ ArrayCreate ac = (ArrayCreate)statement; if (objectId != null && objectId.equals(ac.getArrayObjectId())) { // �z�񐶐��̏ꍇ + boolean isSrcSideChanged = false; if (objectId.equals(srcObject.getId())) { eStructure.addSrcSide(new Reference(thisObj, srcObject)); srcObject = thisObj; trackingObj = srcObject; + isSrcSideChanged = true; } else if(objectId.equals(dstObject.getId())) { eStructure.addDstSide(new Reference(thisObj, dstObject)); dstObject = thisObj; trackingObj = dstObject; + isSrcSideChanged = false; } + aliasCollector.addAlias(new Alias(Alias.AliasType.ARRAY_CREATE, 0, ac.getArrayObjectId(), tracePoint.duplicate())); + aliasCollector.changeTrackingObject(ac.getArrayObjectId(), thisObjectId, isSrcSideChanged); + aliasCollector.addAlias(new Alias(Alias.AliasType.THIS, 0, thisObjectId, tracePoint.duplicate())); if (Trace.isNull(thisObjectId)) objectId = null; // static�ϐ��̏ꍇ else objectId = thisObjectId; objList.set(index, objectId); @@ -458,7 +525,12 @@ ((DeltaAugmentationInfo)childMethodExecution.getAugmentation()).setTraceObjectId(Integer.parseInt(objectId)); TracePoint childTracePoint = tracePoint.duplicate(); childTracePoint.stepBackNoReturn(); - calleeSearch(trace, childTracePoint, objList, childMethodExecution.isStatic(), index); // �Ăяo���������ɒT�� + if (!childMethodExecution.isConstructor()) { + aliasCollector.addAlias(new Alias(Alias.AliasType.METHOD_INVOCATION, 0, ret.getId(), tracePoint.duplicate())); + calleeSearch(trace, childTracePoint, objList, childMethodExecution.isStatic(), index, aliasCollector); // �Ăяo���������ɒT�� + } else { + aliasCollector.addAlias(new Alias(Alias.AliasType.CONSTRACTOR_INVOCATION, 0, ret.getId(), tracePoint.duplicate())); + } if (childMethodExecution.isConstructor()) { // �R���X�g���N�^�Ăяo���������ꍇ if (objectId.equals(srcObject.getId())) { @@ -467,12 +539,16 @@ eStructure.addSrcSide(r); srcObject = thisObj; trackingObj = srcObject; + aliasCollector.changeTrackingObject(objectId, thisObjectId, true); + aliasCollector.addAlias(new Alias(Alias.AliasType.THIS, 0, thisObjectId, tracePoint.duplicate())); } else if (objectId.equals(dstObject.getId())) { r = new Reference(thisObj, dstObject); r.setCreation(true); eStructure.addDstSide(r); dstObject = thisObj; trackingObj = dstObject; + aliasCollector.changeTrackingObject(objectId, thisObjectId, false); + aliasCollector.addAlias(new Alias(Alias.AliasType.THIS, 0, thisObjectId, tracePoint.duplicate())); } if (Trace.isNull(thisObjectId)) objectId = null; // static�ϐ��̏ꍇ else objectId = thisObjectId; @@ -495,14 +571,20 @@ checkList.add(objList.get(index)); isLost = false; } + if (objectId != null) { + if (childMethodExecution.getThisObjId().equals(objectId)) { + aliasCollector.addAlias(new Alias(Alias.AliasType.RECEIVER, 0, objectId, tracePoint.duplicate())); + } + } } } } while (tracePoint.stepBackOver()); //�����T�� - if (argments.contains(new ObjectReference(objectId))) { + if (arguments.contains(new ObjectReference(objectId))) { ((DeltaAugmentationInfo)methodExecution.getAugmentation()).setSetterSide(true); // �������K�v? isResolved = true; + aliasCollector.addAlias(new Alias(Alias.AliasType.FORMAL_PARAMETER, arguments.indexOf(new ObjectReference(objectId)), objectId, methodExecution.getEntryPoint())); } } @@ -510,20 +592,50 @@ Reference r; if (methodExecution.isCollectionType()) { if (objectId != null) { - // �R���N�V�����^�̏ꍇ�A�����ŌX�̗v�f�𒼐ڕێ����Ă���Ɖ��肷�� - if (objectId.equals(srcObject.getId())) { - r = new Reference(thisObj, srcObject); - r.setCollection(true); - eStructure.addSrcSide(r); - srcObject = thisObj; - } else if(objectId.equals(dstObject.getId())) { - r = new Reference(thisObj, dstObject); - r.setCollection(true); - eStructure.addDstSide(r); - dstObject =thisObj; + if (methodExecution.getSignature().contains("Collections.unmodifiable") + || methodExecution.getSignature().contains("Collections.checked") + || methodExecution.getSignature().contains("Collections.synchronized") + || methodExecution.getSignature().contains("Arrays.asList") + || methodExecution.getSignature().contains("Arrays.copyOf")) { + // �z���R���N�V�����̊Ԃ̕ϊ��̏ꍇ�A�ϊ����̑������Ɉˑ����� + if (arguments.size() > 0) { + if (objectId.equals(srcObject.getId())) { + r = new Reference(arguments.get(0), srcObject); + r.setCollection(true); + eStructure.addSrcSide(r); + srcObject = arguments.get(0); + aliasCollector.changeTrackingObject(objectId, arguments.get(0).getId(), true); + aliasCollector.addAlias(new Alias(Alias.AliasType.FORMAL_PARAMETER, 0, arguments.get(0).getId(), tracePoint.duplicate())); + } else if(objectId.equals(dstObject.getId())) { + r = new Reference(arguments.get(0), dstObject); + r.setCollection(true); + eStructure.addDstSide(r); + dstObject =arguments.get(0); + aliasCollector.changeTrackingObject(objectId, arguments.get(0).getId(), false); + aliasCollector.addAlias(new Alias(Alias.AliasType.FORMAL_PARAMETER, 0, arguments.get(0).getId(), tracePoint.duplicate())); + } + } + objList.set(index, arguments.get(0).getId()); + } else { + // �R���N�V�����^�̏ꍇ�A�����ŌX�̗v�f�𒼐ڕێ����Ă���Ɖ��肷�� + if (objectId.equals(srcObject.getId())) { + r = new Reference(thisObj, srcObject); + r.setCollection(true); + eStructure.addSrcSide(r); + srcObject = thisObj; + aliasCollector.changeTrackingObject(objectId, thisObjectId, true); + aliasCollector.addAlias(new Alias(Alias.AliasType.THIS, 0, thisObjectId, tracePoint.duplicate())); + } else if(objectId.equals(dstObject.getId())) { + r = new Reference(thisObj, dstObject); + r.setCollection(true); + eStructure.addDstSide(r); + dstObject =thisObj; + aliasCollector.changeTrackingObject(objectId, thisObjectId, false); + aliasCollector.addAlias(new Alias(Alias.AliasType.THIS, 0, thisObjectId, tracePoint.duplicate())); + } + objList.set(index, methodExecution.getThisObjId()); } } - objList.set(index, methodExecution.getThisObjId()); isResolved = true; // �K�v�Ȃ̂ł�? } @@ -543,4 +655,4 @@ isLost = true; // final�ϐ�������N���X�ŎQ�Ƃ��Ă���”\�������邪�AcalleeSearch()�͕K���Ăяo�����ɕ��A���Ă����̂ŁA�����ł͉������Ȃ� } } -} +} \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java new file mode 100644 index 0000000..f4e5890 --- /dev/null +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java @@ -0,0 +1,995 @@ +package org.ntlab.traceDebugger.analyzerProvider; + +import java.util.ArrayList; +import java.util.Collections; +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.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IMethod; +import org.eclipse.jdt.core.IType; +import org.eclipse.jdt.core.JavaModelException; +import org.eclipse.jdt.core.dom.AST; +import org.eclipse.jdt.core.dom.ASTNode; +import org.eclipse.jdt.core.dom.ASTParser; +import org.eclipse.jdt.core.dom.ASTVisitor; +import org.eclipse.jdt.core.dom.CompilationUnit; +import org.eclipse.jdt.core.dom.Expression; +import org.eclipse.jdt.core.dom.Javadoc; +import org.eclipse.jdt.core.dom.MethodDeclaration; +import org.eclipse.jdt.core.dom.SingleVariableDeclaration; +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.editors.text.FileDocumentProvider; +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.MethodExecution; +import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodInvocation; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Reference; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; +import org.ntlab.traceDebugger.JavaEditorOperator; +import org.ntlab.traceDebugger.JavaElementFinder; + +public class DeltaMarkerManager { + private Map> markerIdToMarkers = new HashMap<>(); + private List markersByOrder = new ArrayList<>(); + private MethodExecution coordinator; + private TracePoint relatedPoint; + private Reference relatedPointReference; + private DeltaRelatedAliasCollector aliasCollector; + 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 static final String DELTA_MARKER_ATR_DATA = "data"; + public static final String DELTA_MARKER_ATR_OBJECT_ID = "objectId"; + public static final String DELTA_MARKER_ATR_OBJECT_TYPE = "objectType"; + public static final String DELTA_MARKER_ATR_ALIAS_TYPE = "aliasType"; + + public DeltaMarkerManager(MethodExecution coordinator, TracePoint relatedPoint, Reference relatedPointReference, DeltaRelatedAliasCollector aliasCollector) { + this.coordinator = coordinator; + this.relatedPoint = relatedPoint; + this.relatedPointReference = relatedPointReference; + this.aliasCollector = aliasCollector; + } + + public Map> getMarkers() { + return markerIdToMarkers; + } + + public List getMarkersByOrder() { + return markersByOrder; + } + + public TreeNode[] getMarkerTreeNodes() { + TreeNode[] roots = new TreeNode[] { + new TreeNode(""), + new TreeNode("Related Aliases"), + new TreeNode("") + }; + List markers; + markers = markerIdToMarkers.get(COORDINATOR_DELTA_MARKER); + roots[0] = new TreeNode(markers.get(0)); + List dstSideMarkers = markerIdToMarkers.get(DST_SIDE_DELTA_MARKER); + List srcSideMarkers = markerIdToMarkers.get(SRC_SIDE_DELTA_MARKER); + int dstSideMarkersSize = (dstSideMarkers != null) ? dstSideMarkers.size() : 0; + int srcSideMarkersSize = (srcSideMarkers != null) ? srcSideMarkers.size() : 0; + TreeNode[] children = new TreeNode[dstSideMarkersSize + srcSideMarkersSize]; + if (dstSideMarkers != null) { + for (int i = 0; i < dstSideMarkers.size(); i++) { + children[i] = new TreeNode(dstSideMarkers.get(i)); + } + } + if (srcSideMarkers != null) { + for (int i = 0; i < srcSideMarkers.size(); i++) { + children[dstSideMarkersSize + i] = new TreeNode(srcSideMarkers.get(i)); + } + } + roots[1].setChildren(children); + markers = markerIdToMarkers.get(BOTTOM_DELTA_MARKER); + roots[2] = new TreeNode(markers.get(0)); + return roots; + } + + public IMarker getCoordinatorDeltaMarker() { + List markers = markerIdToMarkers.get(COORDINATOR_DELTA_MARKER); + if (markers == null || markers.isEmpty()) return null; + return markers.get(0); + } + + public IMarker getBottomDeltaMarker() { + List markers = markerIdToMarkers.get(BOTTOM_DELTA_MARKER); + if (markers == null || markers.isEmpty()) return null; + return markers.get(0); + } + + public static MethodExecution getMethodExecution(IMarker deltaMarker) { + try { + Object data = deltaMarker.getAttribute(DELTA_MARKER_ATR_DATA); + if (data instanceof MethodExecution) { + return (MethodExecution) data; + } else if (data instanceof TracePoint) { + TracePoint tp = (TracePoint)data; + return tp.getMethodExecution(); + } else if (data instanceof Alias) { + Alias alias = (Alias)data; + return alias.getMethodExecution(); + } + } catch (CoreException e) { + e.printStackTrace(); + } + return null; + } + + public static TracePoint getTracePoint(IMarker deltaMarker) { + try { + Object data = deltaMarker.getAttribute(DELTA_MARKER_ATR_DATA); + if (data instanceof MethodExecution) { + return ((MethodExecution)data).getEntryPoint(); + } else if (data instanceof TracePoint) { + return (TracePoint)data; + } else if (data instanceof Alias) { + return ((Alias)data).getOccurrencePoint(); + } + } catch (CoreException e) { + e.printStackTrace(); + } + return null; + } + + public void createMarkerAndOpenJavaFileForAll() { + markAndOpenJavaFileForCoordinator(coordinator, "Coordinator", DeltaMarkerManager.COORDINATOR_DELTA_MARKER); + List dstSideAliases = new ArrayList<>(aliasCollector.getDstSideRelatedAliases()); + List srcSideAliases = new ArrayList<>(aliasCollector.getSrcSideRelatedAliases()); + List> relatedAliasesList = new ArrayList<>(); + relatedAliasesList.add(dstSideAliases); + relatedAliasesList.add(srcSideAliases); + String[] messagesTemplates = {"GetterSide%03d", "SetterSide%03d"}; + String[] markerIDList = {DST_SIDE_DELTA_MARKER, SRC_SIDE_DELTA_MARKER}; + for (int i = 0; i < relatedAliasesList.size(); i++) { + List relatedAliases = relatedAliasesList.get(i); + Collections.reverse(relatedAliases); + int cnt = 1; + for (Alias alias : relatedAliases) { + String message = String.format(messagesTemplates[i], cnt++); + markAndOpenJavaFileForAlias(alias, message, markerIDList[i]); + } + } + markAndOpenJavaFileForCreationPoint(relatedPoint, relatedPointReference, "RelatedPoint", DeltaMarkerManager.BOTTOM_DELTA_MARKER); + } + + private void markAndOpenJavaFileForAlias(Alias alias, String message, String markerId) { + IFile file = JavaElementFinder.findIFile(alias.getMethodExecution()); + if (file != null) { + IMarker marker = addMarkerForAlias(alias, file, message, markerId); + JavaEditorOperator.markAndOpenJavaFile(marker); + } + } + + private void markAndOpenJavaFileForCreationPoint(TracePoint creationPoint, Reference reference, String message, String markerId) { + MethodExecution me = creationPoint.getMethodExecution(); + String objectId = reference.getSrcObjectId() + " -> " + reference.getDstObjectId(); + String objectType = reference.getSrcClassName() + " -> " + reference.getDstClassName(); + IFile file = JavaElementFinder.findIFile(me); + if (file != null) { + IMarker marker = addMarkerForCreationPoint(creationPoint, file, message, objectId, objectType, markerId); + JavaEditorOperator.markAndOpenJavaFile(marker); + } + } + + private void markAndOpenJavaFileForCoordinator(MethodExecution methodExecution, String message, String markerId) { + IFile file = JavaElementFinder.findIFile(methodExecution); + if (file != null) { + String objectId = methodExecution.getThisObjId(); + String objectType = methodExecution.getThisClassName(); + IMarker marker = addMarkerForCoordinator(methodExecution, file, message, objectId, objectType, markerId); + JavaEditorOperator.markAndOpenJavaFile(marker); + } + } + + private IMarker addMarkerForAlias(Alias alias, IFile file, String message, String markerId) { + try { + IMarker marker = file.createMarker(markerId); + Map attributes = new HashMap<>(); + setAttributesForAlias(attributes, alias, file, markerId); + if (!(attributes.containsKey(IMarker.LINE_NUMBER))) { + attributes.put(IMarker.LINE_NUMBER, alias.getLineNo() + " (no marker)"); + } + attributes.put(IMarker.MESSAGE, message); + attributes.put(IMarker.TRANSIENT, true); + attributes.put(DELTA_MARKER_ATR_DATA, alias); + attributes.put(DELTA_MARKER_ATR_OBJECT_ID, alias.getObjectId()); + attributes.put(DELTA_MARKER_ATR_OBJECT_TYPE, alias.getObjectType()); + attributes.put(DELTA_MARKER_ATR_ALIAS_TYPE, alias.getAliasType()); + marker.setAttributes(attributes); + addMarker(markerId, marker); + return marker; + } catch (CoreException e) { + e.printStackTrace(); + } + return null; + } + + private IMarker addMarkerForCreationPoint(TracePoint tp, IFile file, String message, String objectId, String objectType, String markerId) { + try { + MethodExecution me = tp.getMethodExecution(); + int lineNo = tp.getStatement().getLineNo(); + IMarker marker = file.createMarker(markerId); + Map attributes = new HashMap<>(); + setAttributesForCreationPoint(attributes, me, file, lineNo, markerId); + if (!(attributes.containsKey(IMarker.LINE_NUMBER))) attributes.put(IMarker.LINE_NUMBER, tp.getStatement().getLineNo()); + attributes.put(IMarker.MESSAGE, message); + attributes.put(IMarker.TRANSIENT, true); + attributes.put(DELTA_MARKER_ATR_DATA, tp); + attributes.put(DELTA_MARKER_ATR_OBJECT_ID, objectId); + attributes.put(DELTA_MARKER_ATR_OBJECT_TYPE, objectType); + marker.setAttributes(attributes); + addMarker(markerId, marker); + return marker; + } catch (CoreException e) { + e.printStackTrace(); + } + return null; + } + + private IMarker addMarkerForCoordinator(MethodExecution me, IFile file, String message, String objectId, String objectType, String markerId) { + try { + IMarker marker = file.createMarker(markerId); + Map attributes = new HashMap<>(); + setAttributesForCoordinator(attributes, me, file); + 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; + } catch (CoreException e) { + e.printStackTrace(); + } + return null; + } + + private void addMarker(String markerId, IMarker marker) { + List markerList = markerIdToMarkers.get(markerId); + if (markerList == null) { + markerList = new ArrayList(); + markerIdToMarkers.put(markerId, markerList); + } + markerList.add(marker); + markersByOrder.add(marker); + } + + 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); + ASTParser parser = ASTParser.newParser(AST.JLS10); + MethodExecution methodExecution = alias.getMethodExecution(); + IType type = JavaElementFinder.findIType(methodExecution); + IMethod method = JavaElementFinder.findIMethod(methodExecution, type); + if (method != null) { + ICompilationUnit unit = method.getCompilationUnit(); + parser.setSource(unit); + ASTNode node = parser.createAST(new NullProgressMonitor()); + if (node instanceof CompilationUnit) { + CompilationUnit cUnit = (CompilationUnit)node; + ASTVisitor visitor = createVisitor(alias, method, cUnit, attributes); + if (visitor != null) { + node.accept(visitor); + } + } + } + } catch (CoreException e) { + e.printStackTrace(); + } + } + + private ASTVisitor createVisitor(final Alias alias, final IMethod method, final CompilationUnit cUnit, final Map attributes) { + class MyASTVisitor extends ASTVisitor { + public boolean preVisit2(ASTNode node) { + if (attributes.containsKey(IMarker.LINE_NUMBER)) return false; + if (node instanceof org.eclipse.jdt.core.dom.MethodDeclaration) { + try { + // note: �Y�����郁�\�b�h�Ăяo���̏ꍇ�̂ݎq�m�[�h�̒T���𑱍s + String src1 = node.toString().replaceAll(" ", ""); + src1 = src1.substring(0, src1.lastIndexOf("\n")); + String src1Head = src1.substring(0, src1.indexOf(")") + 1); + src1Head = src1Head.replaceAll(" |\t|\r|\n", ""); + src1Head = src1Head.substring(src1Head.indexOf("*/") + 2); // note: �擪�̃R�����g�����O�� + String src2 = method.getSource().replaceAll(" |\t|\r|\n", ""); + return src2.contains(src1Head); + } catch (JavaModelException e) { + e.printStackTrace(); + return false; + } + } + return true; + } + } + ASTVisitor visitor = new MyASTVisitor(); + try { + Statement statement = alias.getOccurrencePoint().getStatement(); + final String source = method.getCompilationUnit().getSource(); + switch (alias.getAliasType()) { + // note: ���\�b�h�ւ̓��� + case FORMAL_PARAMETER: { + final int index = alias.getIndex(); + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.MethodDeclaration node) { + Object obj = node.parameters().get(index); + if (obj instanceof SingleVariableDeclaration) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + SingleVariableDeclaration parameter = (SingleVariableDeclaration)obj; + int start = parameter.getStartPosition(); + int end = start + parameter.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + } + return false; + } + }; + return visitor; + } + case THIS: { + if (statement instanceof FieldAccess) { + final FieldAccess fa = (FieldAccess)statement; + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.FieldAccess node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString(); + String name2 = fa.getFieldName(); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start; + if (source.startsWith("this.", start)) { + end = start + "this".length(); + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ArrayAccess node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + int start = node.getStartPosition(); + int end = start; + if (source.startsWith("this.", start)) { + end = start + "this".length(); + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return true; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.SimpleName node) { + // note: ���\�b�h�Ăяo���̃��V�[�o���t�B�[���h�̏ꍇ�̓t�B�[���h�A�N�Z�X�̃m�[�h���Ɨ��Ȃ�������ɂ���Œʂ� + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + if (!(node.getParent() instanceof org.eclipse.jdt.core.dom.MethodInvocation)) return true; + String name1 = node.toString(); + String name2 = fa.getFieldName(); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start; + if (source.startsWith("this.", start)) { + end = start + "this".length(); + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ClassInstanceCreation node) { + // note: �R���X�g���N�^�Ăяo���̈�����this������ꍇ + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.toString(); + name1 = name1.substring(name1.indexOf("(")); + String name2 = fa.getFieldName(); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.contains(name2))) return true; + int start = node.getStartPosition(); + int end = start; + if (source.startsWith("this.", start)) { + end = start + "this".length(); + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ReturnStatement node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + Expression expression = node.getExpression(); + int start = node.getStartPosition(); + if (expression != null) { + start = node.getExpression().getStartPosition(); + } + int end = start; + if (source.startsWith("this.", start)) { + end = start + "this".length(); + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.IfStatement node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String fieldName = fa.getFieldName(); + fieldName = fieldName.substring(fieldName.lastIndexOf(".") + 1); + int start = node.getStartPosition(); + int end = start; + Expression expression = node.getExpression(); + if (expression != null) { + start = expression.getStartPosition(); + start += expression.toString().indexOf(fieldName); + end = start; + if (source.startsWith("this.", start - "this.".length())) { + start -= "this.".length(); + end = start + "this".length(); + } + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } else if (statement instanceof MethodInvocation) { + final MethodInvocation mi = (MethodInvocation)statement; + final MethodExecution calledMe = mi.getCalledMethodExecution(); + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.MethodInvocation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString() + "("; + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(") + 1); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + String receiverName = node.getExpression().toString(); + int start = node.getStartPosition(); + attributes.put(IMarker.CHAR_START, start); + if (source.startsWith("this.", start)) { + attributes.put(IMarker.CHAR_END, start + "this".length()); + } else { + attributes.put(IMarker.CHAR_END, start + receiverName.length()); + } + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ClassInstanceCreation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.toString(); + name1 = name1.substring("new ".length(), name1.indexOf("(") + 1); + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(") + 1); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start; // note: �R���X�g���N�^�Ăяo���ɑΉ�����this�̓R�[�h���ɂ͏o�Ă��Ȃ����ߒ���0�̃}�[�J�[�ɂ��� + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + case METHOD_INVOCATION: { + if (statement instanceof MethodInvocation) { + final MethodInvocation mi = (MethodInvocation)statement; + final MethodExecution calledMe = mi.getCalledMethodExecution(); + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.MethodInvocation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString() + "("; + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(") + 1); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + Expression expression = node.getExpression(); + String receiverName = ""; + if (expression != null) { + receiverName = expression.toString(); + } + int start = node.getStartPosition(); + if (source.startsWith("this.", start)) { + start += ("this." + receiverName + ".").length(); + } else if (source.startsWith("super.", start)) { + start += ("super." + receiverName + ".").length(); + } else if (!(receiverName.isEmpty())) { + start += (receiverName + ".").length(); + } + int end = node.getStartPosition() + node.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ClassInstanceCreation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.toString(); + name1 = name1.substring("new ".length(), name1.indexOf("(") + 1); + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(name2.lastIndexOf(".") + 1, name2.indexOf("(") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start + node.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + case CONSTRACTOR_INVOCATION: { + if (statement instanceof MethodInvocation) { + final MethodInvocation mi = (MethodInvocation)statement; + final MethodExecution calledMe = mi.getCalledMethodExecution(); + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.ClassInstanceCreation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.toString(); + name1 = name1.substring("new ".length(), name1.indexOf("(") + 1); + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(") + 1); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start + node.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + // note: �ǐՃI�u�W�F�N�g�̐؂�ւ� + case FIELD: { + if (statement instanceof FieldAccess) { + final FieldAccess fa = (FieldAccess)statement; + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.FieldAccess node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString(); + String name2 = fa.getFieldName(); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start + node.getLength(); + if (source.startsWith("this.", start)) { + attributes.put(IMarker.CHAR_START, start + "this.".length()); + } else { + attributes.put(IMarker.CHAR_START, start); + } + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ArrayAccess node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + int start = node.getStartPosition(); + int end = start + node.getArray().toString().length(); + if (source.startsWith("this.", start)) { + attributes.put(IMarker.CHAR_START, start + "this.".length()); + } else { + attributes.put(IMarker.CHAR_START, start); + } + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.SimpleName node) { + // note: ���\�b�h�Ăяo���̃��V�[�o���t�B�[���h�̏ꍇ�̓t�B�[���h�A�N�Z�X�̃m�[�h���Ɨ��Ȃ�������ɂ���Œʂ� + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + if (!(node.getParent() instanceof org.eclipse.jdt.core.dom.MethodInvocation)) return true; + String name1 = node.toString(); + String name2 = fa.getFieldName(); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start + node.getLength(); + if (source.startsWith("this.", start)) { + attributes.put(IMarker.CHAR_START, start + "this.".length()); + } else { + attributes.put(IMarker.CHAR_START, start); + } + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ClassInstanceCreation node) { + // note: �R���X�g���N�^�Ăяo���̈����Ƀt�B�[���h������ꍇ + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.toString(); + name1 = name1.substring(name1.indexOf("(")); + String name2 = fa.getFieldName(); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.contains(name2))) return true; + int start = node.getStartPosition(); + start += (node.toString().indexOf("(") + name1.indexOf(name2)); + int end = start + name2.length(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.ReturnStatement node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + Expression expression = node.getExpression(); + String fieldName = fa.getFieldName(); + fieldName = fieldName.substring(fieldName.lastIndexOf(".") + 1); + int start = node.getStartPosition(); + if (expression != null) { + start = expression.getStartPosition(); + } + int end = start + fieldName.length(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.IfStatement node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String fieldName = fa.getFieldName(); + fieldName = fieldName.substring(fieldName.lastIndexOf(".") + 1); + int start = node.getStartPosition(); + int end = start + node.getLength(); + Expression expression = node.getExpression(); + if (expression != null) { + start = expression.getStartPosition(); + start += expression.toString().indexOf(fieldName); + end = start + fieldName.length(); + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + case CONTAINER: { + if (statement instanceof FieldAccess) { + final FieldAccess fa = (FieldAccess)statement; + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.QualifiedName node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString(); + String name2 = fa.getFieldName(); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start + node.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + case ARRAY_ELEMENT: { + // note: �z��̃Z�b�g�ƃQ�b�g�̃g���[�X�ɂ͍s�ԍ���z�񖼂��L�^����Ă��Ȃ� + if (statement instanceof ArrayAccess) { + final ArrayAccess aa = (ArrayAccess)statement; + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.ArrayAccess node) { + int index = Integer.parseInt(node.getIndex().toString()); + if (index != aa.getIndex()) return true; + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + int start = node.getStartPosition(); + int end = start + node.getLength(); + if (source.startsWith("this.", start)) { + attributes.put(IMarker.CHAR_START, start + "this.".length()); + } else { + attributes.put(IMarker.CHAR_START, start); + } + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + case ARRAY: { + // note: �z��̃Z�b�g�ƃQ�b�g�̃g���[�X�ɂ͍s�ԍ���z�񖼂��L�^����Ă��Ȃ� + if (statement instanceof ArrayAccess) { + final ArrayAccess aa = (ArrayAccess)statement; + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.ArrayAccess node) { + int index = Integer.parseInt(node.getIndex().toString()); + if (index != aa.getIndex()) return true; + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + int start = node.getStartPosition(); + int end = start + node.getArray().toString().length(); + if (source.startsWith("this.", start)) { + attributes.put(IMarker.CHAR_START, start + "this.".length()); + } else { + attributes.put(IMarker.CHAR_START, start); + } + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + case ARRAY_CREATE: { + if (statement instanceof ArrayCreate) { + final ArrayCreate ac = (ArrayCreate)statement; + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.ArrayCreation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != ac.getLineNo()) return true; + int start = node.getStartPosition(); + int end = start + node.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + // note: ���\�b�h����̏o�� + case ACTUAL_ARGUMENT: { + if (statement instanceof MethodInvocation) { + final MethodInvocation mi = (MethodInvocation)statement; + final MethodExecution calledMe = mi.getCalledMethodExecution(); + final int index = alias.getIndex(); + calledMe.getArguments().get(alias.getIndex()); + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.MethodInvocation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString(); + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(")); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + Object obj = node.arguments().get(index); + if (obj instanceof Expression) { + Expression argument = (Expression)obj; + int start = argument.getStartPosition(); + int end = start + argument.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + } + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.SuperMethodInvocation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString(); + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(")); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + Object obj = node.arguments().get(index); + if (obj instanceof Expression) { + Expression argument = (Expression)obj; + int start = argument.getStartPosition(); + int end = start + argument.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + } + return false; + } + }; + } + return visitor; + } + case RECEIVER: { + if (statement instanceof MethodInvocation) { + final MethodInvocation mi = (MethodInvocation)statement; + final MethodExecution calledMe = mi.getCalledMethodExecution(); + visitor = new MyASTVisitor() { + @Override + public boolean visit(org.eclipse.jdt.core.dom.MethodInvocation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString(); + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(")); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start; + Expression expression = node.getExpression(); // note: ���\�b�h�Ăяo���̃��V�[�o�����擾 + if (expression != null) { + String receiverName = expression.toString(); // note: ���\�b�h�Ăяo���̃��V�[�o���܂� + end = start + receiverName.length(); + } + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + @Override + public boolean visit(org.eclipse.jdt.core.dom.SuperMethodInvocation node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + if (lineNo != alias.getLineNo()) return true; + String name1 = node.getName().toString(); + String name2 = calledMe.getCallerSideSignature(); + name2 = name2.substring(0, name2.indexOf("(")); + name2 = name2.substring(name2.lastIndexOf(".") + 1); + if (!(name1.equals(name2))) return true; + int start = node.getStartPosition(); + int end = start + "super".length(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + } + return visitor; + } + case RETURN_VALUE: + // note: �ǂ��Ń��^�[���������̏��(�s�ԍ���)���g���[�X�ɂ͋L�^����Ă��Ȃ� + visitor = new MyASTVisitor(){ + public boolean visit(org.eclipse.jdt.core.dom.ReturnStatement node) { + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + int aliasLineNo = alias.getLineNo(); + if (lineNo < aliasLineNo) return true; // ���ۂɃ��^�[�������ꏊ�̒��O�ɂ���ŏI�X�e�[�g�����g�����O�̃��^�[���͔�΂� + int start = node.getStartPosition(); + int end = start + node.getLength(); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + return false; + } + }; + return visitor; + } + } catch (JavaModelException e) { + e.printStackTrace(); + } + return visitor; + } + + private void setAttributesForCoordinator(final Map attributes, MethodExecution methodExecution, IFile file) { + // note: ���\�b�h�V�O�l�`�����n�C���C�g + IType type = JavaElementFinder.findIType(methodExecution); + final IMethod method = JavaElementFinder.findIMethod(methodExecution, type); + if (method == null) return; + ASTParser parser = ASTParser.newParser(AST.JLS10); + ICompilationUnit unit = method.getCompilationUnit(); + parser.setSource(unit); + ASTNode node = parser.createAST(new NullProgressMonitor()); + if (node instanceof CompilationUnit) { + final CompilationUnit cUnit = (CompilationUnit)node; + node.accept(new ASTVisitor() { + @Override + public boolean visit(MethodDeclaration node) { + try { + if (attributes.containsKey(IMarker.LINE_NUMBER)) return false; + String src1 = node.toString().replaceAll(" ", ""); + src1 = src1.substring(0, src1.lastIndexOf("\n")); + String src1Head = src1.substring(0, src1.indexOf(")") + 1); + String src2 = method.getSource().replaceAll(" |\t|\r|\n", ""); + if (!(src2.contains(src1Head))) return false; + int start = node.getStartPosition(); + int end = start + node.toString().indexOf(")") + 1; + Javadoc javadoc = node.getJavadoc(); + if (javadoc != null) { + start += javadoc.getLength(); + start += 5; // note: node.toString()�Ǝ��ۂ̃R�[�h�̃X�y�[�X���̍��������l�߂鉼���� + String tmp = node.toString().replace(javadoc.toString(), ""); + end = start + tmp.indexOf(")") + 1; + } + int lineNo = cUnit.getLineNumber(node.getStartPosition()); + attributes.put(IMarker.CHAR_START, start); + attributes.put(IMarker.CHAR_END, end); + attributes.put(IMarker.LINE_NUMBER, lineNo); + } catch (JavaModelException e) { + e.printStackTrace(); + } + return false; + } + }); + } + } + + private void setAttributesForCreationPoint(final Map attributes, MethodExecution methodExecution, IFile file, int lineNo, String markerId) { + try { + FileEditorInput input = new FileEditorInput(file); + FileDocumentProvider provider = new FileDocumentProvider(); + provider.connect(input); + IDocument document = provider.getDocument(input); + IRegion lineRegion = document.getLineInformation(lineNo - 1); + attributes.put(IMarker.CHAR_START, lineRegion.getOffset()); + attributes.put(IMarker.CHAR_END, lineRegion.getOffset() + lineRegion.getLength()); + attributes.put(IMarker.LINE_NUMBER, lineNo); + } catch (CoreException | BadLocationException e) { + e.printStackTrace(); + } + } + + private void deleteMarkers(List markerList) { + for (IMarker marker : markerList) { + try { + marker.delete(); + } catch (CoreException e) { + e.printStackTrace(); + } + } + } + + public void clearAllMarkers() { + for (List markerList: markerIdToMarkers.values()) { + deleteMarkers(markerList); + } + markerIdToMarkers.clear(); + markersByOrder.clear(); + } +} diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaRelatedAliasCollector.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaRelatedAliasCollector.java new file mode 100644 index 0000000..d9be4d4 --- /dev/null +++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaRelatedAliasCollector.java @@ -0,0 +1,98 @@ +package org.ntlab.traceDebugger.analyzerProvider; + +import java.util.ArrayList; +import java.util.List; + +public class DeltaRelatedAliasCollector implements IAliasCollector { + private List srcSideRelatedAliases = new ArrayList<>(); + private List dstSideRelatedAliases = new ArrayList<>(); + private List srcSideIdList = new ArrayList<>(); + private List dstSideIdList = new ArrayList<>(); + private List relatedAliases = new ArrayList<>(); + public static final String SRC_SIDE = "SrcSide"; + public static final String DST_SIDE = "DstSide"; + + public DeltaRelatedAliasCollector(String srcId, String dstId) { + srcSideIdList.add(srcId); + dstSideIdList.add(dstId); + } + + @Override + public void addAlias(Alias alias) { + relatedAliases.add(alias); + if (alias == null) return; + String objId = alias.getObjectId(); + String srcOrDst = ""; + if (srcSideIdList.contains(objId) && !(dstSideIdList.contains(objId))) { + if (alias.getAliasType().equals(Alias.AliasType.ACTUAL_ARGUMENT)) { + Alias formalParameterAlias = srcSideRelatedAliases.get(srcSideRelatedAliases.size() - 1); + alias.setIndex(formalParameterAlias.getIndex()); + } + srcSideRelatedAliases.add(alias); + srcOrDst = "Src "; + } else if (dstSideIdList.contains(objId) && !(srcSideIdList.contains(objId))) { + if (alias.getAliasType().equals(Alias.AliasType.ACTUAL_ARGUMENT)) { + Alias formalParameterAlias = dstSideRelatedAliases.get(dstSideRelatedAliases.size() - 1); + alias.setIndex(formalParameterAlias.getIndex()); + } + dstSideRelatedAliases.add(alias); + srcOrDst = "Dst "; + } else if (srcSideIdList.contains(objId) && dstSideIdList.contains(objId)) { + boolean hasSrcSide = false; + for (Alias ra : srcSideRelatedAliases) { + if (ra.getObjectId().equals(objId)) { + hasSrcSide = true; + break; + } + } + if (!hasSrcSide) { + srcSideRelatedAliases.add(alias); + srcOrDst = "Src "; + } else { + dstSideRelatedAliases.add(alias); + srcOrDst = "Dst "; + } + } + + try { + System.out.println(srcOrDst + alias.getAliasType() + ": " + alias.getMethodSignature() + " line" + alias.getLineNo() + " index" + alias.getIndex()); + } catch (Exception e) { + System.out.println(srcOrDst + alias.getAliasType() + ": " + alias.getMethodSignature()); + } + } + + @Override + public void changeTrackingObject(String from, String to, boolean isSrcSide) { + if (isSrcSide) { + srcSideIdList.add(to); + } else { + dstSideIdList.add(to); + } +// if (srcSideIdList.contains(from)) { +// srcSideIdList.add(to); +// } else if (dstSideIdList.contains(from)) { +// dstSideIdList.add(to); +// } + } + + public List getRelatedAliases() { + return relatedAliases; + } + + public List getSrcSideRelatedAliases() { + return srcSideRelatedAliases; + } + + public List getDstSideRelatedAliases() { + return dstSideRelatedAliases; + } + + public String resolveSideInTheDelta(Alias alias) { + int index; + index = srcSideRelatedAliases.indexOf(alias); + if (index != -1) return SRC_SIDE; + index = dstSideRelatedAliases.indexOf(alias); + if (index != -1) return DST_SIDE; + return ""; + } +} diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.java b/src/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.java index 9f0a275..8bea6d8 100644 --- a/src/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.java +++ b/src/org/ntlab/traceDebugger/analyzerProvider/ExtractedStructure.java @@ -1,7 +1,11 @@ package org.ntlab.traceDebugger.analyzerProvider; +import java.util.ArrayList; +import java.util.List; + import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution; import org.ntlab.traceAnalysisPlatform.tracer.trace.Reference; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; public class ExtractedStructure { @@ -10,7 +14,11 @@ private MethodExecution coordinator = null; private MethodExecution parent = null; private MethodExecution creationCallTree; - +// private List srcSideRelatedTracePoints = new ArrayList<>(); +// private List dstSideRelatedTracePoints = new ArrayList<>(); +// private List srcSideRelatedAliases = new ArrayList<>(); +// private List dstSideRelatedAliases = new ArrayList<>(); + public Delta getDelta() { return delta; } @@ -64,5 +72,36 @@ public MethodExecution getCreationCallTree() { return creationCallTree; } + +// public List getSrcSideRelatedTracePoints() { +// return srcSideRelatedTracePoints; +// } +// +// public List getDstSideRelatedTracePoints() { +// return dstSideRelatedTracePoints; +// } +// +// public void addSrcSideRelatedTracePoint(TracePoint tp) { +// srcSideRelatedTracePoints.add(tp); +// } +// +// public void addDstSideRelatedTracePoint(TracePoint tp) { +// dstSideRelatedTracePoints.add(tp); +// } +// public List getSrcSideRelatedAliases() { +// return srcSideRelatedAliases; +// } +// +// public List getDstSideRelatedAliases() { +// return dstSideRelatedAliases; +// } +// +// public void addSrcSideRelatedAlias(Alias alias) { +// srcSideRelatedAliases.add(alias); +// } +// +// public void addDstSideRelatedAlias(Alias alias) { +// dstSideRelatedAliases.add(alias); +// } } diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/IAliasCollector.java b/src/org/ntlab/traceDebugger/analyzerProvider/IAliasCollector.java new file mode 100644 index 0000000..31379f7 --- /dev/null +++ b/src/org/ntlab/traceDebugger/analyzerProvider/IAliasCollector.java @@ -0,0 +1,9 @@ +package org.ntlab.traceDebugger.analyzerProvider; + +public interface IAliasCollector { + + void addAlias(Alias alias); + + void changeTrackingObject(String from, String to, boolean isSrcSide); + +} \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzer.java b/src/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzer.java deleted file mode 100644 index 468a23c..0000000 --- a/src/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzer.java +++ /dev/null @@ -1,237 +0,0 @@ -package org.ntlab.traceDebugger.analyzerProvider; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayAccess; -import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayCreate; -import org.ntlab.traceAnalysisPlatform.tracer.trace.ArrayUpdate; -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.ObjectReference; -import org.ntlab.traceAnalysisPlatform.tracer.trace.Reference; -import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; -import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; -import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; -import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; - -public class ObjectFlowAnalyzer extends AbstractAnalyzer { - private static ObjectFlowAnalyzer getInstance = null; - - public ObjectFlowAnalyzer(Trace trace) { - super(trace); - } - - private static ObjectFlowAnalyzer getInstance() { - if (getInstance == null) { - getInstance = new ObjectFlowAnalyzer(TraceJSON.getInstance()); - } - return getInstance; - } - - public static ArrayList findAllSeedAliasesStatic(MethodExecution me) { - return getInstance().findAllSeedAliases(me); - } - - public ArrayList findAllSeedAliases(MethodExecution me) { - ArrayList seedAliasList = new ArrayList<>(); - List statements = me.getStatements(); - String[] primitives = {"byte", "short", "int", "long", "float", "double", "char", "boolean"}; - List primitiveList = Arrays.asList(primitives); - for (int i = 0; i < statements.size(); i++) { - TracePoint tp = me.getTracePoint(i); - Statement statement = statements.get(i); - if (statement instanceof FieldAccess) { - FieldAccess fa = (FieldAccess)statement; - String objId = fa.getContainerObjId(); - if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fa.getContainerClassName()))) { - seedAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_CONTAINER)); - } - objId = fa.getValueObjId(); - if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fa.getValueClassName()))) { - seedAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_FIELD)); - } - } else if (statement instanceof FieldUpdate) { - FieldUpdate fu = (FieldUpdate)statement; - String objId = fu.getContainerObjId(); - if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fu.getContainerClassName()))) { - seedAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_CONTAINER)); - } - objId = fu.getValueObjId(); - if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fu.getValueClassName()))) { - seedAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_FIELD)); - } - } else if (statement instanceof ArrayAccess) { - ArrayAccess aa = (ArrayAccess)statement; - String valueObjId = aa.getValueObjectId(); - if (valueObjId != null && !(valueObjId.equals("0")) && !(primitiveList.contains(aa.getValueClassName()))) { - seedAliasList.add(new Alias(valueObjId, tp, Alias.OCCURRENCE_EXP_ARRAY)); - } - } else if (statement instanceof ArrayUpdate) { - ArrayUpdate au = (ArrayUpdate)statement; - String valueObjId = au.getValueObjectId(); - if (valueObjId != null && !(valueObjId.equals("0")) && !(primitiveList.contains(au.getValueClassName()))) { - seedAliasList.add(new Alias(valueObjId, tp, Alias.OCCURRENCE_EXP_ARRAY)); - } - } else if (statement instanceof ArrayCreate) { - ArrayCreate ac = (ArrayCreate)statement; - String arrayObjId = ac.getArrayObjectId(); - if (arrayObjId != null && !(arrayObjId.equals("0")) && !(primitiveList.contains(ac.getArrayClassName()))) { - seedAliasList.add(new Alias(arrayObjId, tp, Alias.OCCURRENCE_EXP_RETURN)); - } - } else if (statement instanceof MethodInvocation) { - MethodExecution calledMe = ((MethodInvocation)statement).getCalledMethodExecution(); - String thisObjId = calledMe.getThisObjId(); - if (thisObjId != null && !(thisObjId.equals("0"))) { - seedAliasList.add(new Alias(thisObjId, tp, Alias.OCCURRENCE_EXP_RECEIVER)); - } - List args = calledMe.getArguments(); - for (int j = 0; j < args.size(); j++) { - ObjectReference arg = args.get(j); - String argValueId = arg.getId(); - if (argValueId != null && !(argValueId.equals("0")) && !(primitiveList.contains(arg.getActualType()))) { - seedAliasList.add(new Alias(argValueId, tp, (j + Alias.OCCURRENCE_EXP_FIRST_ARG))); - } - } - ObjectReference returnValue = calledMe.getReturnValue(); - if (returnValue != null) { - String returnValueId = returnValue.getId(); - if (returnValueId != null && !(returnValueId.equals("0") && !(primitiveList.contains(returnValue.getActualType())))) { - seedAliasList.add(new Alias(returnValueId, tp, Alias.OCCURRENCE_EXP_RETURN)); - } - } - } - } - return seedAliasList; - } - - private TracePoint getRecentlyFieldUpdate(TracePoint tp) { - Statement statement = tp.getStatement(); - if (statement instanceof FieldAccess) { - FieldAccess fa = (FieldAccess)statement; - return trace.getFieldUpdateTracePoint(fa.getReference(), tp); - } - return null; - } - - private TracePoint getRecentlyArrayUpdate(TracePoint tp) { - Statement statement = tp.getStatement(); - if (statement instanceof ArrayAccess) { - ArrayAccess aa = (ArrayAccess)statement; - // aa.getReference()���Ȃ��̂ʼn��ɂ�����ۂ�Reference������ēn�� - return trace.getArraySetTracePoint(new Reference(aa.getArrayObjectId(), aa.getValueObjectId(), aa.getArrayClassName(), aa.getValueClassName()), tp); - } - return null; - } - - public static ArrayList> getObjectFlowStatic(Alias startAlias) { - return getInstance().getObjectFlow(startAlias); - } - - public ArrayList> getObjectFlow(Alias startAlias) { - ArrayList> aliasLists = new ArrayList<>(); - ArrayList aliasList = new ArrayList<>(); - aliasLists.add(aliasList); -// aliasList.add(alias); - String objId = startAlias.getObjectId(); - TracePoint tp = startAlias.getOccurrencePoint().duplicate(); - ArrayList> resultLists = getObjectFlow(aliasLists, objId, tp, 0); - return resultLists; - } - - private ArrayList> getObjectFlow(ArrayList> aliasLists, - String objId, TracePoint tp, int side) { - ArrayList aliasList = aliasLists.get(aliasLists.size() - 1); // ����getObjectFlow���\�b�h���s���Ō��‚������G�C���A�X�����Ă������X�g - do { - Statement statement = tp.getStatement(); - if (statement instanceof FieldAccess) { - // �t�B�[���h�Q�Ƃ̏ꍇ - FieldAccess fa = (FieldAccess)statement; - if (fa.getValueObjId().equals(objId)) { - // ���Y�n�_�ł̃G�C���A�X�����X�g�ɒlj��������, �t�B�[���h�ŏI�X�V�ɔ�ԃp�^�[���Ƃ��̂܂ܑk��p�^�[���Ƃŕ��� - aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_FIELD)); - aliasList = new ArrayList<>(aliasList); // ���X�g���̂��f�B�[�v�R�s�[���Ă���(�t�B�[���h�ŏI�X�V�ɔ�ԍċA�����I�����, ���̂܂ܑk��p�^�[���ŗp����) - TracePoint fieldUpdateTp = getRecentlyFieldUpdate(tp); - aliasLists = getObjectFlow(aliasLists, objId, fieldUpdateTp, 0); - aliasLists.add(aliasList); // �ċA�����ɓ���O�Ƀf�B�[�v�R�s�[���Ă������X�g���Ō���ɒlj� (�ȍ~�̑k��ɂ���Č��‚����G�C���A�X�͂��̃��X�g�ɓ������) - } - } else if (statement instanceof ArrayAccess) { - // �z��v�f�Q�Ƃ̏ꍇ - ArrayAccess aa = (ArrayAccess)statement; - if (aa.getValueObjectId().equals(objId)) { - aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_ARRAY)); - aliasList = new ArrayList<>(aliasList); - TracePoint arrayUpdateTp = getRecentlyArrayUpdate(tp); - aliasLists = getObjectFlow(aliasLists, objId, arrayUpdateTp, 0); - aliasLists.add(aliasList); - } - } else if (statement instanceof FieldUpdate) { - // �t�B�[���h�X�V�̏ꍇ - FieldUpdate fu = (FieldUpdate)statement; - if (fu.getValueObjId().equals(objId)) { - aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_FIELD)); - } - } else if (statement instanceof ArrayUpdate) { - // �z��v�f�X�V�̏ꍇ - ArrayUpdate au = (ArrayUpdate)statement; - if (au.getValueObjectId().equals(objId)) { - aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_ARRAY)); - } - } else if (statement instanceof ArrayCreate) { - // �z�񐶐��̏ꍇ - ArrayCreate ac = (ArrayCreate)statement; - if (ac.getArrayObjectId().equals(objId)) { - aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_RETURN)); // �z�񐶐��� new �^��[] �̖߂�l - return aliasLists; // �z�񐶐��ӏ��̓G�C���A�X�̋N���Ȃ̂ł���ȑO�ɂ͂����Ȃ��͂� - } - } else if (statement instanceof MethodInvocation) { - // ���\�b�h�Ăяo���̏ꍇ - MethodExecution calledMethodExecution = ((MethodInvocation)statement).getCalledMethodExecution(); - ObjectReference returnValue = calledMethodExecution.getReturnValue(); - if (returnValue.getId().equals(objId)) { - // �߂�l�ɃG�C���A�X�̃I�u�W�F�N�gID����v�����ꍇ - ArrayList aliasListBeforeMethodBackEntry = new ArrayList<>(aliasList); // �Ăяo����̃��\�b�h���s�ɐ���O�̃G�C���A�X���X�g���R�s�[���Ă��� - aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_RETURN)); - if (calledMethodExecution.isConstructor()) { - return aliasLists; // �R���X�g���N�^�Ăяo���ӏ��̓G�C���A�X�̋N���Ȃ̂ł���ȑO�ɂ͂����Ȃ��͂� - } - TracePoint exitTp = calledMethodExecution.getExitPoint(); // �Ăяo�����\�b�h���s�̍ŏI�X�e�[�g�����g���w��tp���擾 - aliasLists = getObjectFlow(aliasLists, objId, exitTp, side + 1); // �Ăяo����̃��\�b�h���s�ɐ��� - aliasList = aliasLists.get(aliasLists.size() - 1); - if (aliasList.get(aliasList.size() - 1).isOrigin()) { - // �Ăяo����̃��\�b�h���s�ɐ�������ł��̃I�u�W�F�N�g�̋N��(�R���X�g���N�^or�z�񐶐�)�ɓ��B���Ă����ꍇ, �Ăяo����̃��\�b�h���s�ɐ���O�̃��X�g��p���ĐV�K�ɒǐՂ𑱍s���� - aliasLists.add(aliasListBeforeMethodBackEntry); - aliasList = aliasListBeforeMethodBackEntry; - } - } - } - } while (tp.stepBackOver()); // �Ăяo�����ɖ߂邩����ȏ�H��Ȃ��Ȃ�܂Ń��[�v - if (!tp.isValid()) { - return aliasLists; // ����ȏチ�\�b�h���s��k��Ȃ��ꍇ(main���\�b�h�̂���ɑO�Ȃ�)�͂��̎��_�ŏI�� - } - // --- ���̎��_�� tracePoint�� �Ăяo�������w���Ă��� (���O�܂ők���Ă������\�b�h���s�ɂ‚��Ẵ��\�b�h�Ăяo�����w���Ă���) --- - MethodExecution calledMethodExecution = ((MethodInvocation)tp.getStatement()).getCalledMethodExecution(); - ArrayList args = calledMethodExecution.getArguments(); - boolean isExistingInArgs = false; - for (int i = 0; i < args.size(); i++) { - if (args.get(i).getId().equals(objId)) { - // ���\�b�h�Ăяo���̎������ɃG�C���A�X�̃I�u�W�F�N�gID����v�����ꍇ - aliasList.add(new Alias(objId, tp.duplicate(), (i + Alias.OCCURRENCE_EXP_FIRST_ARG))); - isExistingInArgs = true; - if (side == 0) { - // �T���J�n���\�b�h���s�܂��̓t�B�[���h��z��v�f�̍ŏI�X�V�T���Ŕ�񂾐�̃��\�b�h���s����, �X�^�b�N�g���[�X�ł��ǂ��S���\�b�h���s�̏ꍇ - TracePoint previousTp = tp.duplicate(); - previousTp.stepBackOver(); - aliasLists = getObjectFlow(aliasLists, objId, previousTp, 0); // �Ăяo�����̃��\�b�h���s�ɖ߂� - } - } - } - if (!isExistingInArgs) { - aliasLists.remove(aliasLists.size() - 1); // �����ɃG�C���A�X���Ȃ������ꍇ�͂��̉�̒ǐՃG�C���A�X���X�g���폜���� - } - return aliasLists; - } -} diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzerLaunchConfiguration.java b/src/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzerLaunchConfiguration.java deleted file mode 100644 index d48312e..0000000 --- a/src/org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzerLaunchConfiguration.java +++ /dev/null @@ -1,28 +0,0 @@ -package org.ntlab.traceDebugger.analyzerProvider; - -import java.io.IOException; -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.core.runtime.FileLocator; -import org.ntlab.traceAnalysisPlatform.IAdditionalLaunchConfiguration; - -public class ObjectFlowAnalyzerLaunchConfiguration implements IAdditionalLaunchConfiguration { - public static final String ANALYZER_PATH = "org/ntlab/traceDebugger/analyzerProvider/ObjectFlowAnalyzer.class"; - public static final String ANALYZER_PACKAGE = "org.ntlab.traceDebugger.analyzerProvider"; - public static final String ANALYZER_CLASS = "ObjectFlowAnalyzer"; - - @Override - public String[] getAdditionalClasspaths() { - try { - List classPathList = new ArrayList<>(); - String tracerClassPath = FileLocator.resolve(this.getClass().getClassLoader().getResource(ANALYZER_PATH)).getPath(); - String classPath = tracerClassPath.substring(0, tracerClassPath.length() - ANALYZER_PATH.length()); - classPathList.add(classPath); - return classPathList.toArray(new String[classPathList.size()]); - } catch (IOException e) { - e.printStackTrace(); - } - throw new IllegalStateException(); - } -} diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/ReferencePoint.java b/src/org/ntlab/traceDebugger/analyzerProvider/ReferencePoint.java deleted file mode 100644 index f416d50..0000000 --- a/src/org/ntlab/traceDebugger/analyzerProvider/ReferencePoint.java +++ /dev/null @@ -1,90 +0,0 @@ -package org.ntlab.traceDebugger.analyzerProvider; - -import java.util.List; - -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.Reference; -import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; -import org.ntlab.traceAnalysisPlatform.tracer.trace.TraceJSON; -import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; -import org.ntlab.traceDebugger.TraceBreakPoint; - -public class ReferencePoint { - private Reference reference; - private MethodExecution methodExecution; - private Statement statement; - - public ReferencePoint(Reference reference, MethodExecution methodExecution, long beforeTime) { - this.reference = reference; - this.methodExecution = methodExecution; - findFieldUpdate(beforeTime); - } - - public ReferencePoint(Reference reference, MethodExecution methodExecution, Statement statement) { - this.reference = reference; - this.methodExecution = methodExecution; - this.statement = statement; - } - - private void findFieldUpdate(long beforeTime) { - List statements = methodExecution.getStatements(); - for (int i = statements.size() - 1; i >= 0; i--) { - Statement statement = statements.get(i); - if (!(statement instanceof FieldUpdate)) continue; - if (statement.getTimeStamp() > beforeTime) continue; - FieldUpdate fu = (FieldUpdate)statement; - if (fu.getContainerObjId().equals(reference.getSrcObjectId()) - && fu.getValueObjId().equals(reference.getDstObjectId())) { - this.statement = fu; - return; - } - } - } - - public Reference getReference() { - return reference; - } - - public MethodExecution getMethodExecution() { - return methodExecution; - } - - public int getLineNo() { - return (statement != null) ? statement.getLineNo() : -1; - } - - public long getTime() { - if (statement instanceof MethodInvocation) { - return ((MethodInvocation)statement).getCalledMethodExecution().getEntryTime(); - } - return statement.getTimeStamp(); - } - - public TracePoint getTracePoint() { - int order = 0; - for (Statement statement : methodExecution.getStatements()) { - if (statement.equals(this.statement)) break; - order++; - } - return new TracePoint(methodExecution, order); - } - - public String getReferenceMessage() { - if (reference == null) return ""; - StringBuilder ref = new StringBuilder(); - ref.append(reference.getSrcClassName() + "(" + reference.getSrcObjectId() + ")"); - ref.append(" -> "); - ref.append(reference.getDstClassName() + "(" + reference.getDstObjectId() + ")"); - return ref.toString(); - } - - @Override - public String toString() { - int lineNo = getLineNo(); - String location = methodExecution.getSignature() + " line: " + lineNo; - String ref = getReferenceMessage(); - return String.format("%-50s %s", location, ref); - } -} \ No newline at end of file diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/VariableUpdatePointFinder.java b/src/org/ntlab/traceDebugger/analyzerProvider/VariableUpdatePointFinder.java new file mode 100644 index 0000000..d431199 --- /dev/null +++ b/src/org/ntlab/traceDebugger/analyzerProvider/VariableUpdatePointFinder.java @@ -0,0 +1,158 @@ +package org.ntlab.traceDebugger.analyzerProvider; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +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.ObjectReference; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Statement; +import org.ntlab.traceAnalysisPlatform.tracer.trace.ThreadInstance; +import org.ntlab.traceAnalysisPlatform.tracer.trace.Trace; +import org.ntlab.traceAnalysisPlatform.tracer.trace.TracePoint; + +public class VariableUpdatePointFinder { + private static VariableUpdatePointFinder theInstance = new VariableUpdatePointFinder(); + private Trace trace; + private Map>> updatePoints = new HashMap<>(); // �R���e�iID�ƃt�B�[���h�����L�[�ɂ����ϐ��X�V�|�C���g + private Map>> definitionInvocationPoints = new HashMap<>(); // ���V�[�oID�ƈ���ID���L�[�ɂ����R���N�V�����ւ̒lj��|�C���g + private Map gettingIteratorPoints = new HashMap<>(); // �C�e���[�^��ID���L�[�ɂ�����擾�����|�C���g + + public void setTrace(Trace trace) { + this.trace = trace; + init(); + } + + public static VariableUpdatePointFinder getInstance() { + return theInstance; + } + + private void init() { + registerUpdatePoints(); + System.out.println(updatePoints); + System.out.println(definitionInvocationPoints); + sort(updatePoints); + sort(definitionInvocationPoints); + System.out.println(updatePoints); + System.out.println(definitionInvocationPoints); + } + + private void registerUpdatePoints() { + for (Map.Entry entry : trace.getAllThreads().entrySet()) { + ThreadInstance thread = entry.getValue(); + for (MethodExecution me : thread.getRoot()) { + TracePoint start = me.getEntryPoint(); + while (start.stepFull()) { + Statement statement = start.getStatement(); + if (statement instanceof FieldUpdate) { + registerFieldUpdatePoint(start, (FieldUpdate)statement); + } else if (statement instanceof MethodInvocation) { + MethodInvocation mi = (MethodInvocation)statement; + MethodExecution calledME = mi.getCalledMethodExecution(); + String methodName = calledME.getSignature(); + if (methodName.contains(".add(") || methodName.contains(".addElement(")) { + registerdefinitionInvocationPoint(start, calledME); + } else if (methodName.contains(".iterator(") || methodName.contains("Iterator(")) { + registerIteratorPoint(start, calledME); + } + } + } + } + } + } + + private void registerFieldUpdatePoint(TracePoint tp, FieldUpdate fu) { + String objectId = fu.getContainerObjId(); + String fieldName = fu.getFieldName(); + register(updatePoints, objectId, fieldName, tp); + } + +// private void registerdefinitionInvocationPoints(TracePoint tp, MethodInvocation mi) { +// MethodExecution calledME = mi.getCalledMethodExecution(); +// String methodName = calledME.getSignature(); +// List args = calledME.getArguments(); +// if (methodName.contains(".add(") || methodName.contains(".addElement(")) { +// if (args.size() == 1) { +// String receiverId = calledME.getThisObjId(); +// String argId = args.get(0).getId(); +// register(definitionInvocationPoints, receiverId, argId, tp); +// } +// } +// } + + private void registerdefinitionInvocationPoint(TracePoint tp, MethodExecution calledME) { + List args = calledME.getArguments(); + if (args.size() == 1) { + String receiverId = calledME.getThisObjId(); + String argId = args.get(0).getId(); + register(definitionInvocationPoints, receiverId, argId, tp); + } + } + + private void registerIteratorPoint(TracePoint tp, MethodExecution calledME) { + ObjectReference returnIteratorValue = calledME.getReturnValue(); + String iteratorId = returnIteratorValue.getId(); + gettingIteratorPoints.put(iteratorId, tp.duplicate()); + } + + private void register(Map>> map, String key1, String key2, TracePoint tp) { + Map> innerMap = map.get(key1); + if (innerMap == null) { + innerMap = new HashMap<>(); + map.put(key1, innerMap); + } + List tracePoints = innerMap.get(key2); + if (tracePoints == null) { + tracePoints = new ArrayList<>(); + innerMap.put(key2, tracePoints); + } + tracePoints.add(tp.duplicate()); + } + + private void sort(Map>> map) { + for (Map> innerMap : map.values()) { + for (List tracePoints : innerMap.values()) { + Collections.sort(tracePoints, new Comparator() { + @Override + public int compare(TracePoint arg0, TracePoint arg1) { + long time0 = arg0.getStatement().getTimeStamp(); + long time1 = arg1.getStatement().getTimeStamp(); + return (time0 < time1) ? -1 : 1; + } + }); + } + } + } + + public TracePoint getPoint(String objectId, String fieldName, TracePoint before) { + return getPoint(updatePoints, objectId, fieldName, before); + } + + public TracePoint getDefinitionInvocationPoint(String receiverId, String argId, TracePoint before) { + return getPoint(definitionInvocationPoints, receiverId, argId, before); + } + + public TracePoint getIteratorPoint(String iteratorId) { + return gettingIteratorPoints.get(iteratorId); + } + + private TracePoint getPoint(Map>> map, String key1, String key2, TracePoint before) { + Map> innerMap = map.get(key1); + if (innerMap == null) return null; + List tracePoints = innerMap.get(key2); + if (tracePoints == null) return null; + long beforeTime = before.getStatement().getTimeStamp(); + TracePoint tmp = null; + for (TracePoint tp : tracePoints) { + long time = tp.getStatement().getTimeStamp(); + if (time >= beforeTime) return tmp; + tmp = tp; + } + return tmp; + } +}