diff --git a/org.ntlab.reverseDebugger/plugin.xml b/org.ntlab.reverseDebugger/plugin.xml index d79cb2d..124c048 100644 --- a/org.ntlab.reverseDebugger/plugin.xml +++ b/org.ntlab.reverseDebugger/plugin.xml @@ -35,6 +35,13 @@ name="ObjectFlowAliasView" restorable="true"> + + diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java index d46ed53..24d1471 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java @@ -165,7 +165,7 @@ // printCallTreeDataFromRoot(vm, thread, threadInstance); // �I�����C����͒���traceCollector��TraceJSON#getObjectFlow()���Ăяo�����̃R�[�h - printObjectFlow(vm, thread, threadInstance); +// printObjectFlow(vm, thread, threadInstance); } /** @@ -220,9 +220,9 @@ methodName = "get"; Value startAlias = callInstanceMethod(vm, thread, methodName, (ObjectReference)startAliasList, vm.mirrorOf(aliasNo)); - // DebuggingControl������GUI�֘A�̃N���X�̕��ɖ�����V�[�h�G�C���A�X��n���ăI�u�W�F�N�g�t���[�����s���Ă݂� - // �ꎞ�I�Ȃ��̂�, �ŏI�I�ɂ͂����ł�鏈���ł͂Ȃ��Ȃ�̂ŕs�v�ɂȂ�͂� - ObjectFlowAliases.getInstance().getObjectFlow(new MethodCaller(vm, thread, (ObjectReference)startAlias)); +// // DebuggingControl������GUI�֘A�̃N���X�̕��ɖ�����V�[�h�G�C���A�X��n���ăI�u�W�F�N�g�t���[�����s���Ă݂� +// // �ꎞ�I�Ȃ��̂�, �ŏI�I�ɂ͂����ł�鏈���ł͂Ȃ��Ȃ�̂ŕs�v�ɂȂ�͂� +// ObjectFlowAliases.getInstance().getObjectFlow(new MethodCaller(vm, thread, (ObjectReference)startAlias)); // �ȉ��͈ꎞ�I�ɃR�����g�A�E�g���Ă��� // methodName = "toString"; diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/MethodCaller.java b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/MethodCaller.java index eacfc7c..8ed4e37 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/MethodCaller.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/MethodCaller.java @@ -8,9 +8,11 @@ import com.sun.jdi.IncompatibleThreadStateException; import com.sun.jdi.InvalidTypeException; import com.sun.jdi.InvocationException; +import com.sun.jdi.LongValue; import com.sun.jdi.Method; import com.sun.jdi.ObjectReference; import com.sun.jdi.ReferenceType; +import com.sun.jdi.StringReference; import com.sun.jdi.ThreadReference; import com.sun.jdi.Value; import com.sun.jdi.VirtualMachine; @@ -42,6 +44,17 @@ return obj; } + public long getThreadId() { + MethodCaller mc = new MethodCaller(vm, thread, thread); + try { + return ((LongValue)mc.callInstanceMethod("getId")).value(); + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + throw new IllegalStateException(); + } + public MethodCaller setObj(ObjectReference obj) { this.obj = obj; return this; diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackLabelProvider.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackLabelProvider.java new file mode 100644 index 0000000..ce4190e --- /dev/null +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackLabelProvider.java @@ -0,0 +1,49 @@ +package org.ntlab.reversedebugger; + +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.jface.viewers.TreeNode; +import org.eclipse.swt.graphics.Image; +import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.PlatformUI; +import org.ntlab.debuggingControl.MethodCaller; + +import com.sun.jdi.ClassNotLoadedException; +import com.sun.jdi.IncompatibleThreadStateException; +import com.sun.jdi.InvalidTypeException; +import com.sun.jdi.InvocationException; +import com.sun.jdi.ObjectReference; +import com.sun.jdi.StringReference; +import com.sun.jdi.ThreadReference; + +public class CallStackLabelProvider extends LabelProvider { + + @Override + public String getText(Object element) { + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof MethodCaller) { + MethodCaller mc = (MethodCaller)value; + ObjectReference obj = mc.getObj(); + try { + if (obj instanceof ThreadReference) { + return "ThreadID: " + mc.getThreadId(); + } else if (obj != null) { + return ((StringReference)mc.callInstanceMethod("getSignature")).value(); + } + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + } + return ""; + } + + @Override + public Image getImage(Object element) { + if (element instanceof TreeNode) { + return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT); + } + return null; + } +} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackMethodExecutions.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackMethodExecutions.java new file mode 100644 index 0000000..1891548 --- /dev/null +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackMethodExecutions.java @@ -0,0 +1,84 @@ +package org.ntlab.reversedebugger; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.jface.viewers.TreeNode; +import org.ntlab.debuggingControl.MethodCaller; + +import com.sun.jdi.ClassNotLoadedException; +import com.sun.jdi.IncompatibleThreadStateException; +import com.sun.jdi.InvalidTypeException; +import com.sun.jdi.InvocationException; +import com.sun.jdi.ObjectReference; +import com.sun.jdi.ThreadReference; +import com.sun.jdi.Value; +import com.sun.jdi.VirtualMachine; +import com.sun.jdi.event.MethodEntryEvent; + +public class CallStackMethodExecutions { + private List callStackMethodExecutions = new ArrayList(); + + public List getCallStackMethodExecutions() { + return callStackMethodExecutions; + } + + public TreeNode[] getCallStackMethodExecutionsTreeNode() { + TreeNode[] roots = new TreeNode[1]; + if (callStackMethodExecutions.isEmpty()) { + return roots; + } + MethodCaller mc = callStackMethodExecutions.get(0); + roots[0] = new TreeNode(new MethodCaller(mc.getVm(), mc.getThread(), mc.getThread())); + TreeNode parentNode = roots[0]; + TreeNode[] childrenNode = new TreeNode[callStackMethodExecutions.size()]; + parentNode.setChildren(childrenNode); + for (int i = 0; i < callStackMethodExecutions.size(); i++) { + TreeNode childNode = new TreeNode(callStackMethodExecutions.get(i)); + childNode.setParent(parentNode); + childrenNode[i] = childNode; + } + return roots; + } + + public void reset() { + callStackMethodExecutions.clear(); + } + + public void updateByMethodExecution(MethodCaller me) { + if (me == null) { + return; + } + try { + update(me.getVm(), me.getThread(), me.getObj()); + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + + public void updateByAlias(MethodCaller alias) { + if (alias == null) { + return; + } + VirtualMachine vm = alias.getVm(); + ThreadReference thread = alias.getThread(); + try { + ObjectReference me = (ObjectReference)alias.callInstanceMethod("getMethodExecution"); + update(vm, thread, me); + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + } + + private void update(VirtualMachine vm, ThreadReference thread, ObjectReference me) + throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { + callStackMethodExecutions.clear(); + while (me != null) { + MethodCaller mc = new MethodCaller(vm, thread, me); + callStackMethodExecutions.add(mc); + me = (ObjectReference)mc.callInstanceMethod("getParent"); + } + } +} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackView.java new file mode 100644 index 0000000..0bf1e24 --- /dev/null +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/CallStackView.java @@ -0,0 +1,112 @@ +package org.ntlab.reversedebugger; + +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.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.ISharedImages; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.part.ViewPart; +import org.ntlab.debuggingControl.MethodCaller; + +public class CallStackView extends ViewPart { + private static TreeViewer viewer; + private IAction refreshAction; + private IAction resetAction; + private static CallStackMethodExecutions callStackMethodExecutions = new CallStackMethodExecutions(); + private JavaEditorOperator javaEditorOperator = new JavaEditorOperator(); + public static final String ID = "org.ntlab.reverseDebugger.callStackView"; + + public CallStackView() { + // TODO Auto-generated constructor stub + System.out.println("callStackView�N���X���������ꂽ��"); + } + + @Override + public void createPartControl(Composite parent) { + // TODO Auto-generated method stub + System.out.println("CallStackView#createPartControl(Composite)���Ă΂ꂽ��!"); + viewer = new TreeViewer(parent); + viewer.setContentProvider(new TreeNodeContentProvider()); + viewer.setLabelProvider(new CallStackLabelProvider()); + + // �I�������J�����ɑΉ����郁�\�b�h���s�̃\�[�X�t�@�C�����J�����郊�X�i�[��o�^���� + viewer.addSelectionChangedListener(new ISelectionChangedListener() { + @Override + public void selectionChanged(SelectionChangedEvent event) { + IStructuredSelection sel = (IStructuredSelection)event.getSelection(); + Object element = sel.getFirstElement(); + if (element instanceof TreeNode) { + Object value = ((TreeNode)element).getValue(); + if (value instanceof MethodCaller) { + MethodCaller methodExecution = (MethodCaller)value; + javaEditorOperator.openSrcFileOfMethodExecution(methodExecution); + } + } + } + }); + createActions(); + createToolBar(); + createMenuBar(); + } + + @Override + public void setFocus() { + // TODO Auto-generated method stub + viewer.getControl().setFocus(); + } + + private void createActions() { + refreshAction = new Action() { + @Override + public void run() { + refresh(); + } + }; + refreshAction.setText("���t���b�V��"); + refreshAction.setToolTipText("���t���b�V��"); + refreshAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_INFO_TSK)); + + resetAction = new Action() { + @Override + public void run() { + callStackMethodExecutions.reset(); + viewer.refresh(); + } + }; + resetAction.setText("���Z�b�g"); + resetAction.setToolTipText("���Z�b�g"); + resetAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJS_WARN_TSK)); + } + + private void createToolBar() { + IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager(); + mgr.add(refreshAction); + mgr.add(resetAction); + } + + private void createMenuBar() { + IMenuManager mgr = getViewSite().getActionBars().getMenuManager(); + mgr.add(refreshAction); + mgr.add(resetAction); + } + + public static void updateByAlias(MethodCaller alias) { + callStackMethodExecutions.updateByAlias(alias); + } + + public static void refresh() { + if (callStackMethodExecutions.getCallStackMethodExecutions().isEmpty()) { + MethodCaller currentMe = SeedAliasView.getCurrentMethodExecution(); + callStackMethodExecutions.updateByMethodExecution(currentMe); + } + viewer.setInput(callStackMethodExecutions.getCallStackMethodExecutionsTreeNode()); + } +} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/JavaEditorOperator.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/JavaEditorOperator.java index 0c537de..33a603e 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/JavaEditorOperator.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/JavaEditorOperator.java @@ -30,8 +30,8 @@ public class JavaEditorOperator { private static final String TRACE = "org.ntlab.traceCollector.tracer.trace"; - - public void openSrcFile(MethodCaller alias) { + + public void openSrcFileOfAlias(MethodCaller alias) { try { ObjectReference methodExecution = (ObjectReference)alias.callInstanceMethod("getMethodExecution"); MethodCaller meCaller = new MethodCaller(alias.getVm(), alias.getThread(), methodExecution); @@ -47,14 +47,18 @@ * * @param meCaller */ - private void openSrcFileOfMethodExecution(MethodCaller meCaller) - throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { - IType type = findIType(meCaller); - if (type != null) { - IMethod method = findIMethod(meCaller, type); - if (method != null) { - openSrcFileOfIMethod(type, method); - } + public void openSrcFileOfMethodExecution(MethodCaller meCaller) { + try { + IType type = findIType(meCaller); + if (type != null) { + IMethod method = findIMethod(meCaller, type); + if (method != null) { + openSrcFileOfIMethod(type, method); + } + } + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java index 3df254a..9a48a29 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasLabelProvider.java @@ -38,7 +38,8 @@ case 5: return String.format("%3d", (((IntegerValue)mc.callInstanceMethod("getOccurrenceExp")).value())); } - } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { e.printStackTrace(); } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java index 8b312f1..e2e5642 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliasView.java @@ -22,10 +22,10 @@ import org.ntlab.debuggingControl.MethodCaller; public class ObjectFlowAliasView extends ViewPart { - private TableViewer viewer; + private static TableViewer viewer; private IAction refreshAction; private IAction resetAction; - private ObjectFlowAliases objectFlowAliases = ObjectFlowAliases.getInstance(); + private static ObjectFlowAliases objectFlowAliases = new ObjectFlowAliases(); private JavaEditorOperator javaEditorOperator = new JavaEditorOperator(); public static final String ID = "org.ntlab.reverseDebugger.objectFlowAliasView"; @@ -33,6 +33,10 @@ // TODO Auto-generated constructor stub System.out.println("ObjectFlowView�N���X���������ꂽ��!"); } + + public static ObjectFlowAliases getObjectFlowAliases() { + return objectFlowAliases; + } @Override public void createPartControl(Composite parent) { @@ -64,8 +68,11 @@ Object element = sel.getFirstElement(); if (element instanceof MethodCaller) { MethodCaller alias = (MethodCaller)element; - SeedAliases.getInstance().createSeedAliases(alias); - javaEditorOperator.openSrcFile(alias); + SeedAliasView.createSeedAliases(alias); + SeedAliasView.refresh(); + CallStackView.updateByAlias(alias); + CallStackView.refresh(); + javaEditorOperator.openSrcFileOfAlias(alias); } } }); @@ -85,8 +92,7 @@ refreshAction = new Action() { @Override public void run() { - viewer.setInput(objectFlowAliases.getObjectFlowSingleList(true)); -// viewer.refresh(); + refresh(); } }; refreshAction.setText("���t���b�V��"); @@ -97,6 +103,7 @@ @Override public void run() { objectFlowAliases.reset(); + viewer.setInput(objectFlowAliases.getObjectFlowSingleList(true)); } }; resetAction.setText("���Z�b�g"); @@ -115,4 +122,12 @@ mgr.add(refreshAction); mgr.add(resetAction); } + + public static void createObjectFlow(MethodCaller seedAlias) { + objectFlowAliases.createObjectFlow(seedAlias); + } + + public static void refresh() { + viewer.setInput(objectFlowAliases.getObjectFlowSingleList(true)); + } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java index 212b61b..b76640c 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ObjectFlowAliases.java @@ -15,21 +15,9 @@ import com.sun.jdi.VirtualMachine; public class ObjectFlowAliases { - private static ObjectFlowAliases theInstance = null; private List> objectFlowAliases = new ArrayList<>(); private static final String TRACE = "org.ntlab.traceCollector.tracer.trace"; - - private ObjectFlowAliases() { - - } - - public static ObjectFlowAliases getInstance() { - if (theInstance == null) { - theInstance = new ObjectFlowAliases(); - } - return theInstance; - } - + public void reset() { objectFlowAliases.clear(); } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ReverseDebuggerPerspective.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ReverseDebuggerPerspective.java index 84e8115..45e4808 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ReverseDebuggerPerspective.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/ReverseDebuggerPerspective.java @@ -11,17 +11,17 @@ public void createInitialLayout(IPageLayout layout) { // �G�f�B�^�̏ꏊ���擾 String editorArea = layout.getEditorArea(); - - // ����ɂ̓X�^�b�N�̃r���[��z�u����\�肾��, �Ή�ID��������Ȃ��̂łƂ肠�������ɃA�E�g���C����z�u���Ă��� - IFolderLayout topLeft = layout.createFolder("topLeft", IPageLayout.TOP, 0.35f, editorArea); - topLeft.addView(IPageLayout.ID_OUTLINE); + // ����ɃR�[���X�^�b�N�̃r���[��z�u + IFolderLayout topLeft = layout.createFolder("topLeft", IPageLayout.TOP, 0.35f, editorArea); + topLeft.addView(CallStackView.ID); + // �E��ɃV�[�h�G�C���A�X�̃r���[��z�u IFolderLayout topRight = layout.createFolder("topRight", IPageLayout.RIGHT, 0.35f, "topLeft"); topRight.addView(SeedAliasView.ID); - // ����ɃI�u�W�F�N�g�t���[�G�C���A�X�̃r���[��z�u + // �E���ɃI�u�W�F�N�g�t���[�G�C���A�X�̃r���[��z�u IFolderLayout bottomRight = layout.createFolder("bottomRight", IPageLayout.RIGHT, 0.35f, editorArea); - bottomRight.addView(ObjectFlowAliasView.ID); + bottomRight.addView(ObjectFlowAliasView.ID); } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java index 6b5b1cc..b5e4437 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliasView.java @@ -25,12 +25,11 @@ import org.ntlab.debuggingControl.MethodCaller; public class SeedAliasView extends ViewPart { - private TableViewer viewer; + private static TableViewer viewer; private IAction refreshAction; private IAction resetAction; - private SeedAliases seedAliases = SeedAliases.getInstance(); + private static SeedAliases seedAliases = new SeedAliases(); public static final String ID = "org.ntlab.reverseDebugger.seedAliasView"; -// private ISelectionListener listener; public SeedAliasView() { // TODO Auto-generated constructor stub @@ -67,31 +66,15 @@ Object element = sel.getFirstElement(); if (element instanceof MethodCaller) { MethodCaller seedAlias = (MethodCaller)element; - ObjectFlowAliases.getInstance().createObjectFlow(seedAlias); + ObjectFlowAliasView.createObjectFlow(seedAlias); + ObjectFlowAliasView.refresh(); } } - }); - -// listener = new ISelectionListener() { -// @Override -// public void selectionChanged(IWorkbenchPart part, ISelection selection) { -// System.out.println("test"); -// System.out.println(part); -// System.out.println(selection); -// } -// }; -// getSite().getPage().addSelectionListener(listener); - + }); createActions(); createToolBar(); createMenuBar(); } - - @Override - public void dispose() { -// getSite().getPage().removeSelectionListener(listener); - super.dispose(); - } @Override public void setFocus() { @@ -104,10 +87,7 @@ refreshAction = new Action() { @Override public void run() { - if (seedAliases.getSeedAliases().isEmpty()) { - seedAliases.initSeedAliases(); - } - viewer.refresh(); + refresh(); } }; refreshAction.setText("���t���b�V��"); @@ -118,6 +98,7 @@ @Override public void run() { seedAliases.reset(); + viewer.refresh(); } }; resetAction.setText("���Z�b�g"); @@ -136,4 +117,19 @@ mgr.add(refreshAction); mgr.add(resetAction); } + + public static MethodCaller getCurrentMethodExecution() { + return seedAliases.getCurrentMethodExecution(); + } + + public static void createSeedAliases(MethodCaller alias) { + seedAliases.createSeedAliases(alias); + } + + public static void refresh() { + if (seedAliases.getSeedAliases().isEmpty()) { + seedAliases.initSeedAliases(); + } + viewer.refresh(); + } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java index a4ce80d..cdd58c4 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reversedebugger/SeedAliases.java @@ -31,19 +31,16 @@ import com.sun.jdi.VirtualMachine; public class SeedAliases { - public static SeedAliases theInstance = null; + private MethodCaller currentMethodExecution = null; private List seedAliases = new ArrayList<>(); private final String TRACER = "org.ntlab.traceCollector.tracer.trace"; - private SeedAliases() { + public SeedAliases() { initSeedAliases(); } - public static SeedAliases getInstance() { - if (theInstance == null) { - theInstance = new SeedAliases(); - } - return theInstance; + public MethodCaller getCurrentMethodExecution() { + return currentMethodExecution; } public List getSeedAliases() { @@ -101,6 +98,7 @@ // threadId�ɑΉ�����ThreadInstance���擾 ObjectReference threadInstance = (ObjectReference)mc.callStaticMethod(TRACER, "TraceJSON", "getThreadInstance", threadId); Value methodExecution = mc.setObj(threadInstance).callInstanceMethod("getCurrentMethodExecution"); + currentMethodExecution = new MethodCaller(vm, thread, (ObjectReference)methodExecution); findAllSeedAlias(vm, thread, methodExecution); } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { e.printStackTrace(); @@ -112,10 +110,13 @@ * @param alias */ public void createSeedAliases(MethodCaller alias) { - MethodCaller mc = new MethodCaller(alias.getVm(), alias.getThread()); + VirtualMachine vm = alias.getVm(); + ThreadReference thread = alias.getThread(); + MethodCaller mc = new MethodCaller(vm, thread); try { Value methodExecution = alias.callInstanceMethod("getMethodExecution"); - findAllSeedAlias(alias.getVm(), alias.getThread(), methodExecution); + currentMethodExecution = new MethodCaller(vm, thread); + findAllSeedAlias(vm, thread, methodExecution); } catch (InvalidTypeException | ClassNotLoadedException | InvocationException | IncompatibleThreadStateException e) { e.printStackTrace(); }